@adatechnology/game-test-room 0.20.0 → 0.22.0

package/dist/index.js

@@ -1,13 +1,92 @@
 // src/room.ts
 import { createDestruction, JOINT_DEFAULTS, resolveStrings as resolveDestructionStrings } from "@adatechnology/game-destruction";
-import { createAudioEngine, createAudioSink } from "@adatechnology/game-audio";
-import { createDestructionRenderer, createDestructionSound, dragSoundKey, impactKey, specFromObject3D } from "@adatechnology/game-destruction-three";
+import { createAudioEngine, createAudioSink, loadKitSamples } from "@adatechnology/game-audio";
+import { createDestructionRenderer, createDestructionSound, dragSoundKey, impactKey, impactSoundKeys, specFromObject3D } from "@adatechnology/game-destruction-three";
+import { bodyMass, KNOCK_CHEST, knockOf, surfaceOfMaterial } from "@adatechnology/game-contracts";
+
+// src/body-sounds.ts
+import { BODY_FOLEY_BANK } from "@adatechnology/game-audio";
+import { SWING_LEAD_SECONDS, hitSoundId, landSoundId, swingSoundId } from "@adatechnology/game-contracts";
+var DEFAULT_TOOL_BLOWS = {
+  hand: "punch",
+  fists: "punch",
+  kick: "kick",
+  shove: "shove",
+  knife: "blade",
+  machete: "blade",
+  utility_knife: "blade",
+  axe: "chop",
+  hammer: "blunt",
+  claw_hammer: "blunt",
+  sledgehammer: "blunt",
+  baseball_bat: "blunt",
+  crowbar: "blunt",
+  wrench: "blunt"
+};
+function blowOfTool(id, category, table = DEFAULT_TOOL_BLOWS) {
+  const listed = table[id];
+  if (listed) return listed;
+  if (category === "melee_blade") return "blade";
+  if (category === "melee_blunt" || category === "hand") return id === "kick" ? "kick" : "blunt";
+  return null;
+}
+var levelOf = (energyJ) => Math.max(0.5, Math.min(1, 0.5 + energyJ / 800));
+var STRIDE_METRES = { walk: 0.72, run: 1.05 };
+var SLAM_HURT_SPEED = 3.5;
+function createBodySounds(audio) {
+  audio?.register(BODY_FOLEY_BANK);
+  const played = [];
+  const play = (id, position, volume, delay = 0) => {
+    played.push(id);
+    if (played.length > 64) played.shift();
+    audio?.play(id, { position, volume, urgent: true, ...delay > 0 ? { delay } : {} });
+  };
+  return {
+    swing(blow, position, delay = 0) {
+      const id = swingSoundId(blow);
+      if (id) play(id, position, 0.8, delay);
+    },
+    hit(blow, target, position, energyJ) {
+      play(hitSoundId(blow, target), position, levelOf(energyJ));
+    },
+    jump: (position) => play("jump", position, 0.6),
+    land: (surface, speed, position) => play(landSoundId(surface, speed), position, Math.min(1, 0.45 + speed / 8)),
+    slam(speed, position) {
+      play("body_fall", position, Math.min(1, 0.4 + speed / 8));
+      if (speed >= SLAM_HURT_SPEED) play("player_hurt", position, Math.min(1, 0.5 + speed / 12));
+    },
+    played
+  };
+}
+var swingLead = (blow) => SWING_LEAD_SECONDS[blow];
+function createStrideCounter(stride = STRIDE_METRES) {
+  let left = stride.walk / 2;
+  let next = "right";
+  return {
+    advance(metres, gait) {
+      left -= metres;
+      if (left > 0) return null;
+      left += stride[gait];
+      const foot = next;
+      next = next === "right" ? "left" : "right";
+      return foot;
+    },
+    reset() {
+      left = stride.walk / 2;
+      next = "right";
+    }
+  };
+}
+
+// src/room.ts
 import { createArsenal, DEFAULT_LOADOUT } from "@adatechnology/game-weapons";
 import { createFilmLcg, createFluids, createItemUse, ITEM_USES, resolveStrings as resolveFluidStrings } from "@adatechnology/game-fluids";
 import { createFilmBridge, createFilmManager, createFluidRenderer } from "@adatechnology/game-fluids-three";
 import { SPRITE_KINDS, createVfx, patchSpriteKinds } from "@adatechnology/game-vfx";
 import { createVfxRenderer } from "@adatechnology/game-vfx-three";
-import { checkAnimation, checkBench, checkDestructible, checkSpec, createEnvironmentBus, sealBlock, sealOpener, shotExtras, twistStroke, TWIST_LIFT, useToHit } from "@adatechnology/game-contracts";
+import { createFramePacer, createGeometryPool, createLightBudget, createMaterialPool, createProgramWarmup, createStaticBatcher, spriteProbes } from "@adatechnology/game-render-three";
+import { DEFERRED_PRIORITY, DEFERRED_QUEUE_ID, checkAnimation, checkBench, checkDestructible, checkSpec, createEnvironmentBus, sealBlock, sealOpener, shotExtras, twistStroke, TWIST_LIFT, useToHit } from "@adatechnology/game-contracts";
+import { createScheduler, startLoop } from "@adatechnology/game-runtime";
 
 // src/arena.ts
 import { markKitOrigin } from "@adatechnology/game-contracts";
@@ -242,6 +321,38 @@ function createArena(THREE, size, scene, scenery, tapOption) {
   };
 }
 
+// src/hand-sounds.ts
+import { LEAF_FOLEY_SETS } from "@adatechnology/game-audio";
+function pickupClassOf(def) {
+  if (!def) return "plastic";
+  const tags = def.tags ?? [];
+  if (def.id === "paper") return "paper";
+  if (tags.includes("metal")) return "metal";
+  if (tags.includes("glass") || tags.includes("ceramic")) return "glass";
+  if (tags.includes("plastic") || tags.includes("rubber")) return "plastic";
+  if (tags.includes("wood")) return "wood";
+  if (tags.includes("fabric")) return "fabric";
+  if (tags.includes("plant")) return "food";
+  return "plastic";
+}
+var pickupSoundOf = (sounds, def) => `item_pickup_${sounds?.handling ?? pickupClassOf(def)}`;
+function leafFoleyOf(sounds, part, impactKey2, slides2) {
+  const named = sounds?.leaves?.[part] ?? sounds?.leaves?.["*"];
+  const set = named ? LEAF_FOLEY_SETS[named] : void 0;
+  if (set) return set;
+  if (slides2) return LEAF_FOLEY_SETS.drawer;
+  return /metal|glass/.test(impactKey2) ? LEAF_FOLEY_SETS.metal_door : LEAF_FOLEY_SETS.wood_door;
+}
+var openSoundOf = (sounds, def) => sounds?.open ?? (pickupClassOf(def) === "metal" ? "can_open" : "bottle_open");
+var USE_SOUNDS = {
+  drink: "drink_gulp",
+  sip: "drink_gulp",
+  chug: "drink_gulp",
+  eat: "eat_chew"
+};
+var USE_SOUND_EVERY = 0.55;
+var useSoundOf = (sounds, useId) => sounds?.uses?.[useId] ?? USE_SOUNDS[useId];
+
 // src/bench.ts
 var snap = (control, value) => {
   const clamped = Math.min(control.max, Math.max(control.min, value));
@@ -691,7 +802,7 @@ function createExplosives(context) {
     if (!detonation.cone) told(results);
     if (detonation.energy > 0) {
       const isPlayed = context.effects.explosion(detonation.explosive, detonation.point, { direction: detonation.direction }) !== null;
-      renderer.explode(detonation.point, detonation.energy, reach, { visual: !isPlayed, report: results });
+      renderer.explode(detonation.point, detonation.energy, reach, { visual: !isPlayed, report: results, effect: detonation.explosive });
     }
     if (detonation.stunSeconds !== void 0) renderer.emit("flash", detonation.point, [0, 1, 0], 1, 1);
     const onPlayer = blastEffect(detonation, toArray(camera.position));
@@ -1187,6 +1298,91 @@ function createLoading(options) {
   };
 }
 
+// src/graphics.ts
+import { createGraphicsController, frameLoad, targetFrameMs } from "@adatechnology/game-graphics";
+import { createFpsOverlay, createGraphicsScreen } from "@adatechnology/game-graphics/screen";
+import { createGpuFrameTimer, createGraphicsView, gpuName } from "@adatechnology/game-graphics-three";
+var QUIET_FRAMES = 10;
+function createRoomGraphics(o) {
+  const view = createGraphicsView({ renderer: o.gl, camera: o.camera, sun: o.sun });
+  const seconds = o.options.calibrationSeconds ?? 3;
+  const controller = createGraphicsController({
+    store: { ...o.options.storage !== void 0 ? { storage: o.options.storage } : {}, ...o.options.key ? { key: o.options.key } : {} },
+    gpu: gpuName(o.gl),
+    benchmark: seconds > 0 ? { durationS: seconds } : false,
+    // the room measures its own frames once it is up, not the loading of its content
+    calibrate: "manual",
+    apply: (e) => view.apply(e)
+  });
+  const timer = createGpuFrameTimer(o.gl);
+  const screen = o.ui ? createGraphicsScreen({ container: o.container, controller, locale: o.locale }) : null;
+  const overlay = o.ui ? createFpsOverlay({ container: o.container, controller, locale: o.locale }) : null;
+  const listeners = /* @__PURE__ */ new Set();
+  let lastHorde = controller.settings.hordeDetail;
+  const unsubscribe = controller.subscribe(() => {
+    if (controller.settings.hordeDetail === lastHorde) return;
+    lastHorde = controller.settings.hordeDetail;
+    for (const l of listeners) l();
+  });
+  let task = null;
+  const syncTask = () => {
+    if (controller.phase === "calibrating") {
+      task ?? (task = o.loading.begin(o.label, { total: 100 }));
+      task.step(`${Math.round(controller.calibrationProgress * 100)}%`, Math.round(controller.calibrationProgress * 100));
+    } else if (task) {
+      task.end();
+      task = null;
+    }
+  };
+  syncTask();
+  let started = 0;
+  let quiet = 0;
+  let lastEnd = 0;
+  return {
+    controller,
+    view,
+    screen,
+    host: {
+      hordeDetail: () => controller.settings.hordeDetail,
+      onChange(listener) {
+        listeners.add(listener);
+        return () => listeners.delete(listener);
+      },
+      report: (key2, value) => controller.report(key2, value)
+    },
+    frameStart() {
+      started = performance.now();
+    },
+    beforeRender(camera) {
+      view.hold();
+      view.follow(camera.position.x, camera.position.z);
+      timer.begin();
+    },
+    afterRender() {
+      timer.end();
+    },
+    frameEnd() {
+      const now = performance.now();
+      const realSeconds = lastEnd > 0 ? (now - lastEnd) / 1e3 : 0;
+      lastEnd = now;
+      if (!(realSeconds > 0)) return;
+      const cpuMs = started > 0 ? now - started : realSeconds * 1e3;
+      controller.frame(realSeconds, frameLoad({ cpuMs, gpuMs: timer.ms, intervalMs: realSeconds * 1e3, targetMs: targetFrameMs(controller.settings.fpsCap) }));
+      quiet = o.loading.active && !task ? 0 : quiet + 1;
+      if (o.options.calibrate !== "manual" && quiet >= QUIET_FRAMES) controller.calibrateIfNeeded();
+      syncTask();
+    },
+    dispose() {
+      task?.end();
+      unsubscribe();
+      listeners.clear();
+      timer.dispose();
+      screen?.dispose();
+      overlay?.dispose();
+    }
+  };
+}
+
 // src/log.ts
 var MAX_ENTRIES = 5e3;
 var pad = (n, w = 2) => String(n).padStart(w, "0");
@@ -1316,8 +1512,12 @@ function createLog(options = {}) {
 }
 
 // src/metrics.ts
-var ROOM_METRICS = ["fps", "frame_ms", "draw_calls", "triangles", "objects", "fragments", "particles", "decals", "blast_shelter", "blast_confinement", "blast_fragments"];
+var ROOM_METRICS = ["fps", "frame_ms", "draw_calls", "triangles", "objects", "fragments", "particles", "decals", "blast_shelter", "blast_confinement", "blast_fragments", "geometries", "textures", "heap_mb"];
 var WINDOW_S = 0.5;
+function heapMB() {
+  const memory = globalThis.performance?.memory;
+  return typeof memory?.usedJSHeapSize === "number" ? memory.usedJSHeapSize / 1048576 : void 0;
+}
 function createRoomMetrics(sources) {
   const wanted = new Set(sources.ids);
   const gl = sources.gl;
@@ -1353,6 +1553,9 @@ function createRoomMetrics(sources) {
       const render = ownsRender ? { calls, triangles } : gl.info?.render;
       put("draw_calls", render?.calls);
       put("triangles", render?.triangles);
+      put("geometries", gl.info?.memory?.geometries);
+      put("textures", gl.info?.memory?.textures);
+      put("heap_mb", heapMB());
       const blast = sources.blast?.();
       if (blast) {
         put("blast_shelter", blast.shelter * 100);
@@ -1372,6 +1575,43 @@ function createRoomMetrics(sources) {
   };
 }
 
+// src/memory-watch.ts
+function createMemoryWatch(options) {
+  const clears = Math.max(2, options.clears ?? 4);
+  const budget = { geometries: options.budget?.geometries ?? 40, textures: options.budget?.textures ?? 4 };
+  const histories = /* @__PURE__ */ new Map();
+  let last;
+  return {
+    cleared(where) {
+      const now = options.read();
+      if (!now) return void 0;
+      const key2 = where ?? "";
+      const history = histories.get(key2) ?? [];
+      histories.set(key2, history);
+      history.push(now);
+      if (history.length > clears + 1) history.shift();
+      const first = history[0];
+      const grew = { geometries: now.geometries - first.geometries, textures: now.textures - first.textures };
+      let growing = history.length === clears + 1;
+      for (let i = 1; growing && i < history.length; i++) {
+        const before = history[i - 1];
+        const after = history[i];
+        growing = after.geometries > before.geometries || after.textures > before.textures;
+      }
+      const leaking = growing && (grew.geometries > budget.geometries || grew.textures > budget.textures);
+      last = { after: now, grew, leaking };
+      return last;
+    },
+    get last() {
+      return last;
+    },
+    reset() {
+      histories.clear();
+      last = void 0;
+    }
+  };
+}
+
 // src/narrate.ts
 var SKIP_DAMAGE = /* @__PURE__ */ new Set(["fire", "heat"]);
 function createNarrator(c) {
@@ -1885,6 +2125,9 @@ function createNarrator(c) {
 }
 
 // src/player.ts
+import { stepKnock } from "@adatechnology/game-contracts";
+var SLAM_MIN_SPEED = 1.5;
+var LANDING_MIN_SPEED = 1;
 var EYE = 1.7;
 var PLAYER_RADIUS = 0.3;
 var FOOT = 0.5;
@@ -1901,6 +2144,9 @@ var GRAVITY = 13;
 var FLOOR_CLIMB_SPEED = 3;
 var FLOOR_FALL_SPEED = 6;
 var LOOK = 22e-4;
+var LYING_EYE = 0.3;
+var LYING_PITCH = 1.05;
+var LYING_ROLL = 0.35;
 function createPlayer(THREE, o) {
   const cam = o.camera;
   let yaw = 0;
@@ -1911,6 +2157,7 @@ function createPlayer(THREE, o) {
   let bend = 0;
   let bendTarget = 0;
   let vy = 0;
+  let floorUnder = 0;
   let walked = 0;
   let running = false;
   const px = { x: o.start[0], z: o.start[2] };
@@ -1937,10 +2184,15 @@ function createPlayer(THREE, o) {
     const reach = (gap > 0 ? FLOOR_CLIMB_SPEED : FLOOR_FALL_SPEED) * dt;
     floorLevel += Math.max(-reach, Math.min(reach, gap));
   };
+  let knocked = null;
+  let rollSide = 1;
   const apply = () => {
-    euler.set(pitch, yaw, 0, "YXZ");
+    const lying = knocked?.lying ?? 0;
+    const fallen = lying * lying * (3 - 2 * lying);
+    euler.set(pitch + (LYING_PITCH - pitch) * fallen, yaw, LYING_ROLL * rollSide * fallen, "YXZ");
     cam.quaternion.setFromEuler(euler);
-    cam.position.set(px.x, eye + floorLevel + y - CROUCH_DROP * crouch - bend, px.z);
+    const standing = eye - CROUCH_DROP * crouch - bend;
+    cam.position.set(px.x, floorLevel + y + standing + (LYING_EYE - standing) * fallen, px.z);
     cam.updateMatrixWorld(true);
   };
   apply();
@@ -2115,6 +2367,41 @@ function createPlayer(THREE, o) {
   window.addEventListener("keyup", onKeyUp);
   window.addEventListener("blur", onBlur);
   window.addEventListener("beforeunload", onBeforeUnload);
+  const stepKnocked = (dt) => {
+    const k = knocked;
+    if (!k) return;
+    const floor = Math.max(floorHere(), o.footing?.(px.x, px.z, PLAYER_RADIUS * FOOT, y).floor ?? -Infinity);
+    floorUnder = floor;
+    const at = { x: px.x, y, z: px.z };
+    const fromY = y;
+    const fallSpeed = Math.max(0, -k.velocity[1]);
+    const done = stepKnock(k, at, dt, () => floor, true);
+    const wantX = at.x - px.x;
+    const wantZ = at.z - px.z;
+    const fromX = px.x;
+    const fromZ = px.z;
+    const vx = k.velocity[0];
+    const vz = k.velocity[2];
+    move(wantX, wantZ);
+    const stoppedX = Math.abs(wantX) > 1e-6 && Math.abs(px.x - fromX) < Math.abs(wantX) * 0.5;
+    const stoppedZ = Math.abs(wantZ) > 1e-6 && Math.abs(px.z - fromZ) < Math.abs(wantZ) * 0.5;
+    if (stoppedX) k.velocity[0] = 0;
+    if (stoppedZ) k.velocity[2] = 0;
+    const into = Math.hypot(stoppedX ? vx : 0, stoppedZ ? vz : 0);
+    if (into >= SLAM_MIN_SPEED) o.onSlam?.({ against: "obstacle", speed: into, direction: [stoppedX ? vx / into : 0, 0, stoppedZ ? vz / into : 0] });
+    y = at.y;
+    if (fromY > floor && y <= floor) {
+      const speed = Math.max(fallSpeed, (fromY - y) / Math.max(dt, 1e-6));
+      if (k.down && speed >= SLAM_MIN_SPEED * 0.5) o.onSlam?.({ against: "ground", speed: Math.hypot(speed, Math.hypot(vx, vz) * 0.5), direction: [0, -1, 0] });
+      else if (speed >= LANDING_MIN_SPEED) o.onFeet?.({ type: "land", speed });
+    }
+    vy = 0;
+    walked = dt > 0 ? Math.hypot(px.x - fromX, px.z - fromZ) / dt : 0;
+    running = false;
+    if (done) knocked = null;
+    followFloor(dt);
+    apply();
+  };
   return {
     get walkIntent() {
       return walkKeys();
@@ -2163,11 +2450,35 @@ function createPlayer(THREE, o) {
     get running() {
       return running;
     },
+    get grounded() {
+      return y <= floorUnder + 1e-3 && vy <= 0;
+    },
     get crouching() {
       return isCrouched();
     },
     keys,
+    knock(next) {
+      if (seated) return;
+      if (knocked) {
+        knocked.velocity = [knocked.velocity[0] + next.velocity[0], knocked.velocity[1] + next.velocity[1], knocked.velocity[2] + next.velocity[2]];
+        knocked.airborne || (knocked.airborne = next.airborne);
+        knocked.down || (knocked.down = next.down);
+      } else knocked = { ...next, velocity: [...next.velocity] };
+      if (next.down) {
+        const right = Math.cos(yaw) * next.velocity[0] - Math.sin(yaw) * next.velocity[2];
+        rollSide = right >= 0 ? -1 : 1;
+        crouchLatched = false;
+      }
+      if (knocked.airborne) vy = Math.max(vy, knocked.velocity[1]);
+    },
+    get knocked() {
+      return knocked;
+    },
     update(dt) {
+      if (knocked) {
+        stepKnocked(dt);
+        return;
+      }
       if (crouchPress) crouchPress.held += dt;
       const crouched = isCrouched();
       crouch += ((crouched ? 1 : 0) - crouch) * Math.min(1, dt * CROUCH_RATE);
@@ -2188,13 +2499,18 @@ function createPlayer(THREE, o) {
         return;
       }
       const floor = Math.max(floorHere(), o.footing?.(px.x, px.z, PLAYER_RADIUS * FOOT, y).floor ?? -Infinity);
+      floorUnder = floor;
       if (y < floor && vy <= 0) y = floor;
-      if (y <= floor && keys.has("Space") && !walkHeld) vy = JUMP;
+      if (y <= floor && keys.has("Space") && !walkHeld) {
+        vy = JUMP;
+        o.onFeet?.({ type: "jump" });
+      }
       if (y > floor || vy > 0) {
         vy -= GRAVITY * dt;
         y += vy * dt;
         if (y <= floor) {
           y = floor;
+          if (-vy >= LANDING_MIN_SPEED) o.onFeet?.({ type: "land", speed: -vy });
           vy = 0;
         }
       }
@@ -2202,6 +2518,7 @@ function createPlayer(THREE, o) {
       apply();
     },
     setPose(position, yw, pt) {
+      knocked = null;
       px.x = position[0];
       px.z = position[2];
       floorLevel = floorHere();
@@ -2213,6 +2530,7 @@ function createPlayer(THREE, o) {
       apply();
     },
     look(position, target) {
+      knocked = null;
       px.x = position[0];
       px.z = position[2];
       floorLevel = floorHere();
@@ -2569,6 +2887,8 @@ var TURN_RATE = 8;
 var MAX_WALK_SECONDS = 1.5;
 var APPROACH_SPEED2 = 3;
 var FLOOR_GAP = 0.03;
+var LEAF_SLAM_VOLUME = 0.85;
+var shutVolume = (massKg) => Math.min(1, 0.3 + massKg * 0.03);
 var key = (objectId, part) => `${objectId}\0${part}`;
 var slides = (clip, part) => {
   const last = clip.keys[clip.keys.length - 1]?.parts?.[part];
@@ -2814,7 +3134,7 @@ function createRoomDoors(options) {
     using = { objectId, leaf, obj, grip, pull, phase: control.phase, progress: 0, walked: 0, there: goal === null };
     const at = obj.localToWorld(grip.clone());
     if (goal === null) {
-      options.sound("leaf_rattle", [at.x, at.y, at.z], 0.6);
+      options.sound(options.leafFoley?.(objectId, leaf.part, slides(leaf.clip, leaf.part))?.locked ?? "leaf_rattle", [at.x, at.y, at.z], 0.6);
       event("locked", using);
     } else event("reach", using);
     return true;
@@ -2899,17 +3219,27 @@ function createRoomDoors(options) {
       const at = u.obj.localToWorld(tmp.copy(u.grip));
       const point = [at.x, at.y, at.z];
       const slide = slides(u.leaf.clip, u.leaf.part);
-      const shut = options.impactKey(u.objectId, u.leaf.part).replace("impact_", "leaf_shut_");
+      const foley = options.leafFoley?.(u.objectId, u.leaf.part, slide) ?? null;
+      const own = (moment) => options.leafSound?.(u.objectId, u.leaf.part, moment);
+      const shut = own("shut") ?? options.impactKey(u.objectId, u.leaf.part).replace("impact_", "leaf_shut_");
       if (wasPhase === "reach" && s.phase !== "reach") {
-        if (slide) options.sound("leaf_slide", point, 0.5);
-        else {
+        const opening = foley ? void 0 : own("open");
+        if (foley) {
+          if (was < 0.02) options.sound(foley.open, point, 0.5);
+          if (foley.turn) options.sound(foley.turn, point, 0.35);
+        } else if (slide) options.sound("leaf_slide", point, 0.5);
+        else if (opening) {
+          if (was < 0.02) options.sound(opening, point, 0.5);
+        } else {
           if (was < 0.02) options.sound("leaf_latch", point, 0.5);
           options.sound(/metal|glass/.test(shut) ? "leaf_creak_metal" : "leaf_creak_wood", point, 0.35);
         }
       }
       if (s.arrived) {
         if (s.opening <= 0) {
-          options.sound(slide ? "leaf_slide" : shut, point, Math.min(1, 0.3 + massOf(u.objectId, u.leaf.part) * 0.03));
+          const volume = shutVolume(massOf(u.objectId, u.leaf.part));
+          if (foley) options.sound(foley.slam && volume >= LEAF_SLAM_VOLUME ? foley.slam : foley.close, point, volume);
+          else options.sound(slide ? "leaf_slide" : shut, point, volume);
           event("closed", u);
         } else event("opened", u);
       }
@@ -3121,6 +3451,11 @@ var en = {
     "metric.fragments": "Fragments",
     "metric.particles": "Particles",
     "metric.decals": "Decals",
+    "metric.geometries": "Geometries",
+    "metric.textures": "Textures",
+    "metric.heap_mb": "Heap MB",
+    "memory.leak_short": "memory leak: +{geometries} geometries, +{textures} textures per {clears} clears",
+    "memory.leak": "Memory keeps growing after each clear: +{geometries} geometries and +{textures} textures over the last {clears} clears. Something removed from the scene was not released (discardObject3D).",
     "act.spawn": "Spawned {name} at x {x} \xB7 z {z}",
     "act.clear": "Cleared the room",
     "act.reset": "Repaired every object",
@@ -3167,11 +3502,18 @@ var en = {
     "act.throw": "Threw {name} at {speed} m/s",
     "ground.name": "Ground",
     "act.landing": "{name} landed at {speed} m/s: {energy} J",
+    "act.player_land": "You landed at {speed} m/s",
     "act.bench_failed": "{name} failed: {error}",
     "loading.working": "Working\u2026",
+    "loading.graphics": "Calibrating graphics\u2026",
+    "ui.graphics": "Graphics",
     "loading.open_area": "Opening {area}\u2026",
     "loading.spawn": "Building {name}\u2026",
     "act.loosened": "{name} was heavy but free: the blast moved it",
+    "act.knocked_down": "The blast threw the player off their feet at {speed} m/s ({reach}% got through the cover)",
+    "act.player_slammed": "The player was thrown into {what} at {speed} m/s",
+    "act.player_fell": "The player hit the floor at {speed} m/s",
+    "act.player_shoved": "The blast pushed the player at {speed} m/s ({reach}% got through the cover)",
     "act.came_apart": "{name} came apart: what stayed is loose and falls",
     "act.shoved": "{name} stands free: the shots moved it",
     "act.impact": "{name} hit {where} at {speed} m/s: {energy} J of blunt damage",
@@ -3471,6 +3813,11 @@ var ptBR = {
     "metric.fragments": "Fragmentos",
     "metric.particles": "Part\xEDculas",
     "metric.decals": "Decalques",
+    "metric.geometries": "Geometrias",
+    "metric.textures": "Texturas",
+    "metric.heap_mb": "Heap MB",
+    "memory.leak_short": "vazamento de mem\xF3ria: +{geometries} geometrias, +{textures} texturas em {clears} limpezas",
+    "memory.leak": "A mem\xF3ria continua subindo a cada limpeza: +{geometries} geometrias e +{textures} texturas nas \xFAltimas {clears} limpezas. Algo tirado da cena n\xE3o foi liberado (discardObject3D).",
     "act.spawn": "Criou {name} em x {x} \xB7 z {z}",
     "act.clear": "Limpou a sala",
     "act.reset": "Consertou todos os objetos",
@@ -3517,11 +3864,18 @@ var ptBR = {
     "act.throw": "Arremessou {name} a {speed} m/s",
     "ground.name": "Ch\xE3o",
     "act.landing": "{name} caiu a {speed} m/s: {energy} J",
+    "act.player_land": "Voc\xEA aterrissou a {speed} m/s",
     "act.bench_failed": "{name} falhou: {error}",
     "loading.working": "Trabalhando\u2026",
+    "loading.graphics": "Calibrando os gr\xE1ficos\u2026",
+    "ui.graphics": "Gr\xE1ficos",
     "loading.open_area": "Abrindo {area}\u2026",
     "loading.spawn": "Montando {name}\u2026",
     "act.loosened": "{name} \xE9 pesado mas estava solto: a explos\xE3o o moveu",
+    "act.knocked_down": "A explos\xE3o derrubou o jogador a {speed} m/s ({reach}% passou pela cobertura)",
+    "act.player_slammed": "O jogador foi arremessado contra {what} a {speed} m/s",
+    "act.player_fell": "O jogador bateu no ch\xE3o a {speed} m/s",
+    "act.player_shoved": "A explos\xE3o empurrou o jogador a {speed} m/s ({reach}% passou pela cobertura)",
     "act.came_apart": "{name} se desmontou: o que ficou est\xE1 solto e cai",
     "act.shoved": "{name} estava solto no ch\xE3o: os tiros o moveram",
     "act.impact": "{name} bateu em {where} a {speed} m/s: {energy} J de dano de impacto",
@@ -4110,6 +4464,7 @@ var CSS = `
 .tr-top{position:absolute;top:8px;left:50%;transform:translateX(-50%);text-align:center;max-width:46vw}
 .tr-tool{display:inline-block;background:rgba(10,12,16,.72);padding:4px 12px;border-radius:6px;font-size:14px;font-weight:600}
 .tr-tool small{font-weight:400;opacity:.8;margin-left:8px}
+.tr-alert{display:none;position:relative;z-index:20;margin-top:6px;background:rgba(183,28,28,.92);color:#fff;padding:6px 12px;border-radius:6px;font-size:13px;font-weight:600;box-shadow:0 2px 8px rgba(0,0,0,.4)}
 .tr-status{margin-top:4px;min-height:16px;color:#ffd23f;text-shadow:0 1px 2px #000}
 .tr-prog{margin:4px auto 0;width:260px;background:rgba(10,12,16,.72);border-radius:6px;padding:4px 8px;display:none}
 .tr-prog b{display:block;font-weight:500;margin-bottom:3px}
@@ -4228,13 +4583,14 @@ function createUi(o) {
   const top = mk3("div", "tr-top");
   const toolBox = mk3("div", "tr-tool");
   const status = mk3("div", "tr-status");
+  const alertBox = mk3("div", "tr-alert");
   const prog = mk3("div", "tr-prog");
   const progLabel = mk3("b");
   const progBar = mk3("div", "tr-bar");
   const progFill = mk3("i");
   progBar.appendChild(progFill);
   prog.append(progLabel, progBar);
-  top.append(toolBox, status, prog);
+  top.append(toolBox, alertBox, status, prog);
   const bottom = mk3("div", "tr-bottom");
   const held = mk3("div", "tr-held");
   const hotbar = mk3("div", "tr-hotbar");
@@ -4345,9 +4701,16 @@ function createUi(o) {
       nodes.delete(oldest.value);
       logBody.firstElementChild?.remove();
     }
-    if (autoscroll) logBody.scrollTop = logBody.scrollHeight;
+    if (autoscroll) isScrollDue = true;
   }
+  let isScrollDue = false;
+  const scrollToEnd = () => {
+    if (!isScrollDue) return;
+    isScrollDue = false;
+    logBody.scrollTop = logBody.scrollHeight;
+  };
   const flushLog = () => {
+    scrollToEnd();
     if (pendingAdds.length === 0 && pendingUpdates.size === 0) return;
     if (!isLogVisible()) {
       isLogStale = true;
@@ -4461,17 +4824,22 @@ function createUi(o) {
   fullscreenBtn.title = t("ui.fullscreen.hint");
   const blastBtns = ["shelter", "fragmentHits", "confinement"].map((key2) => ({ key: key2, b: ctl(t(`ui.blast.${key2}`), () => o.onBlast(key2)) }));
   for (const { key: key2, b } of blastBtns) b.title = t(`ui.blast.${key2}.hint`);
-  const qSel = mk3("select");
-  for (const q of ["low", "medium", "high"]) {
-    const op = mk3("option", void 0, t(`ui.quality.${q}`));
-    op.value = q;
-    qSel.appendChild(op);
+  if (o.onGraphics) {
+    const g = ctl(t("ui.graphics"), () => o.onGraphics());
+    g.dataset.testid = "graphics-button";
+  } else {
+    const qSel = mk3("select");
+    for (const q of ["low", "medium", "high"]) {
+      const op = mk3("option", void 0, t(`ui.quality.${q}`));
+      op.value = q;
+      qSel.appendChild(op);
+    }
+    qSel.value = o.quality;
+    qSel.onchange = () => o.onQuality(qSel.value);
+    const qLabel = mk3("label", void 0, t("ui.quality") + " ");
+    qLabel.appendChild(qSel);
+    controls.appendChild(qLabel);
   }
-  qSel.value = o.quality;
-  qSel.onchange = () => o.onQuality(qSel.value);
-  const qLabel = mk3("label", void 0, t("ui.quality") + " ");
-  qLabel.appendChild(qSel);
-  controls.appendChild(qLabel);
   const count = mk3("span");
   controls.appendChild(count);
   cat.appendChild(controls);
@@ -4697,6 +5065,10 @@ function createUi(o) {
         renderInspector(s.inspect);
       }
     },
+    alert(text) {
+      alertBox.textContent = text ?? "";
+      alertBox.style.display = text ? "block" : "none";
+    },
     toast(text) {
       status.textContent = text;
       if (toastTimer) clearTimeout(toastTimer);
@@ -4731,9 +5103,144 @@ function createUi(o) {
   return api;
 }
 
+// src/module-views.ts
+var FRAME_PX = 3;
+function createModuleViews(THREE, gl) {
+  const entries = [];
+  let mainCamera = null;
+  const overlay = new THREE.Scene();
+  const ortho = new THREE.OrthographicCamera(-0.5, 0.5, 0.5, -0.5, 0, 2);
+  ortho.position.z = 1;
+  const plane = new THREE.PlaneGeometry(1, 1);
+  const roundedMask = (rounded, aspect) => {
+    if (!rounded || typeof document === "undefined") return null;
+    const canvas = document.createElement("canvas");
+    canvas.width = 256;
+    canvas.height = Math.max(16, Math.round(256 / aspect));
+    const g = canvas.getContext("2d");
+    if (!g) return null;
+    const r = Math.min(canvas.width, canvas.height) * Math.min(0.5, rounded);
+    g.fillStyle = "#000";
+    g.fillRect(0, 0, canvas.width, canvas.height);
+    g.fillStyle = "#fff";
+    g.beginPath();
+    g.roundRect(0, 0, canvas.width, canvas.height, r);
+    g.fill();
+    const texture = new THREE.CanvasTexture(canvas);
+    texture.colorSpace = THREE.NoColorSpace;
+    return texture;
+  };
+  const size = () => {
+    if (typeof gl.getSize !== "function") return { w: 960, h: 600 };
+    const v = new THREE.Vector2();
+    gl.getSize(v);
+    return { w: v.x, h: v.y };
+  };
+  const take = (entry) => {
+    const i = entries.indexOf(entry);
+    if (i < 0) return;
+    entries.splice(i, 1);
+    overlay.remove(entry.quad, entry.frame);
+    entry.target.dispose();
+    entry.quad.material.dispose();
+    entry.frame.material.dispose();
+    entry.alpha?.dispose();
+  };
+  return {
+    add(view) {
+      const { w, h } = size();
+      const scale = view.resolution ?? 0.5;
+      const pr = typeof gl.getPixelRatio === "function" ? gl.getPixelRatio() : 1;
+      const target = new THREE.WebGLRenderTarget(Math.max(16, Math.round(w * view.rect.width * pr * scale)), Math.max(16, Math.round(h * view.rect.height * pr * scale)), { samples: 2 });
+      target.texture.colorSpace = THREE.LinearSRGBColorSpace;
+      const alpha = roundedMask(view.rounded ?? 0, w * view.rect.width / Math.max(1, h * view.rect.height));
+      const quad = new THREE.Mesh(plane, new THREE.MeshBasicMaterial({ map: target.texture, side: THREE.DoubleSide, depthTest: false, depthWrite: false, ...alpha ? { alphaMap: alpha, transparent: true } : {} }));
+      const frame = new THREE.Mesh(plane, new THREE.MeshBasicMaterial({ color: 723982, side: THREE.DoubleSide, depthTest: false, depthWrite: false, ...alpha ? { alphaMap: alpha, transparent: true } : {} }));
+      quad.renderOrder = 1;
+      frame.visible = quad.visible = false;
+      overlay.add(frame, quad);
+      const entry = { view, target, quad, frame, alpha };
+      entries.push(entry);
+      return () => take(entry);
+    },
+    setMain(camera) {
+      mainCamera = camera;
+    },
+    main(fallback) {
+      if (!mainCamera) return fallback;
+      const persp = mainCamera;
+      const back = fallback;
+      if (persp.isPerspectiveCamera && back.isPerspectiveCamera && persp.aspect !== back.aspect) {
+        persp.aspect = back.aspect;
+        persp.updateProjectionMatrix();
+      }
+      return mainCamera;
+    },
+    render(scene) {
+      if (!entries.length) return;
+      const { w, h } = size();
+      const autoClear = gl.autoClear;
+      const shadows = gl.shadowMap.autoUpdate;
+      gl.shadowMap.autoUpdate = false;
+      for (const entry of entries) {
+        const cam = entry.view.camera;
+        const aspect = w * entry.view.rect.width / Math.max(1, h * entry.view.rect.height);
+        if (cam.isPerspectiveCamera && Math.abs(cam.aspect - aspect) > 1e-3) {
+          cam.aspect = aspect;
+          cam.updateProjectionMatrix();
+        }
+        gl.setRenderTarget(entry.target);
+        gl.clear();
+        gl.render(scene, cam);
+      }
+      gl.setRenderTarget(null);
+      gl.autoClear = false;
+      gl.setScissorTest(true);
+      for (const entry of entries) {
+        const r = entry.view.rect;
+        const x = r.x * w;
+        const y = (1 - r.y - r.height) * h;
+        const vw = r.width * w;
+        const vh = r.height * h;
+        for (const mesh of [entry.frame, entry.quad]) mesh.visible = false;
+        entry.frame.visible = true;
+        gl.setViewport(x - FRAME_PX, y - FRAME_PX, vw + 2 * FRAME_PX, vh + 2 * FRAME_PX);
+        gl.setScissor(x - FRAME_PX, y - FRAME_PX, vw + 2 * FRAME_PX, vh + 2 * FRAME_PX);
+        gl.render(overlay, ortho);
+        entry.frame.visible = false;
+        entry.quad.visible = true;
+        entry.quad.scale.x = entry.view.mirror ? -1 : 1;
+        gl.setViewport(x, y, vw, vh);
+        gl.setScissor(x, y, vw, vh);
+        gl.render(overlay, ortho);
+        entry.quad.visible = false;
+      }
+      gl.setScissorTest(false);
+      gl.setViewport(0, 0, w, h);
+      gl.autoClear = autoClear;
+      gl.shadowMap.autoUpdate = shadows;
+    },
+    get count() {
+      return entries.length;
+    },
+    dispose() {
+      for (const entry of [...entries]) take(entry);
+      plane.dispose();
+      mainCamera = null;
+    }
+  };
+}
+
 // src/room.ts
 var FIXED_DT = 1 / 60;
+var EXPLOSIVE_EFFECT_IDS = ["m67", "molotov", "pipe_bomb", "m79_40mm", "m72_66mm", "at4_84mm", "dynamite", "c4", "claymore"];
+var DEFAULT_PARTICLE_LIMIT = 900;
+var WARMED_FOG_STATES = ["none", "linear", "exp2"];
+var ROOM_LIGHT_SIZES = { point: 16, spot: 4, pointShadows: 0, hemisphere: 1 };
 var SOLID_SPAN = 3;
+var BATCH_MIN_MESHES = 8;
+var BATCH_BUDGET_MS = 1;
+var UNBATCHED_OWNERS = /vehicles|characters|animals|crowd/;
 var STEP_UP = 0.45;
 var BODY_HEIGHT2 = 1.75;
 var KICK_MASS = 6;
@@ -4752,6 +5259,12 @@ var CAP_RISE = 0.03;
 var MAX_STRIDE_SPEED = 10;
 var v3 = (v) => [v.x, v.y, v.z];
 var dist3 = (a, b) => Math.hypot(a[0] - b[0], a[1] - b[1], a[2] - b[2]);
+var vehicleLeafKey = (spec, part, moment) => {
+  const tags = spec.parts.find((p) => p.id === part)?.tags ?? [];
+  const leaf = tags.includes("hood") ? "hood" : tags.includes("lid") || tags.includes("trunk") ? "trunk" : "door";
+  return `vehicle_${leaf}_${moment}`;
+};
+var MARK_EVENTS = /* @__PURE__ */ new Set(["dent", "hole", "crack", "chip", "stage", "fracture"]);
 function createTestRoom(options) {
   const THREE = options.THREE;
   const locale = options.locale ?? "en";
@@ -4798,9 +5311,21 @@ function createTestRoom(options) {
   };
   const onResize = () => resize();
   window.addEventListener("resize", onResize);
+  const moduleViews = createModuleViews(THREE, gl);
   const arenaSize = options.arenaSize ?? 14;
   const arena = createArena(THREE, arenaSize, scene, options.scenery, options.tap);
   scene.add(arena.group);
+  const graphics = ownRenderer && options.graphics ? createRoomGraphics({
+    gl,
+    camera,
+    sun: arena.sun,
+    container,
+    locale,
+    loading,
+    label: t("loading.graphics"),
+    ui: options.ui !== false,
+    options: options.graphics === true ? {} : options.graphics
+  }) : null;
   const ownWorld = !options.world;
   const world = options.world ?? createDestruction({ seed: 1, ...options.worldOptions, materials: [...options.worldOptions?.materials ?? []] });
   const pristineWorld = ownWorld ? world.serialize() : null;
@@ -4846,12 +5371,30 @@ function createTestRoom(options) {
   const ownAudio = options.audio === void 0;
   const audio = options.audio === false ? null : options.audio ?? createAudioEngine({ deferredStart: {} });
   const destructionSound = audio ? createDestructionSound(audio) : null;
-  const playSound = (key2, point, volume) => {
-    destructionSound?.onSound(key2, point, volume);
-    options.onSound?.(key2, point, volume);
-  };
+  if (audio && options.samplesBaseUrl !== null) {
+    void loadKitSamples(audio, { baseUrl: options.samplesBaseUrl ?? "./sfx/" }).then((bank) => {
+      if (!bank || typeof window === "undefined") return;
+      const preload = () => {
+        window.removeEventListener("keydown", preload, true);
+        window.removeEventListener("pointerdown", preload, true);
+        void audio.loadSamples(["latch", "creak_wood", "shut_wood", "rattle", "grab_hard", "grab_soft"]).catch(() => void 0);
+      };
+      window.addEventListener("keydown", preload, true);
+      window.addEventListener("pointerdown", preload, true);
+    });
+  }
+  const bodySounds = createBodySounds(audio);
+  const playSound = (key2, point, volume, detail) => {
+    destructionSound?.onSound(key2, point, volume, detail);
+    if (detail) options.onSound?.(key2, point, volume, detail);
+    else options.onSound?.(key2, point, volume);
+  };
+  const lights = createLightBudget(THREE, scene, { ...ROOM_LIGHT_SIZES, ...options.lightSizes });
+  const warmup = createProgramWarmup(THREE);
+  const pools = { geometries: createGeometryPool(), materials: createMaterialPool({ anchors: warmup.anchors, renderer: gl }) };
   const vfx = createVfxRenderer(THREE, {
     scene,
+    lights,
     camera,
     overlay: container,
     quality,
@@ -4914,7 +5457,7 @@ function createTestRoom(options) {
     const size = Math.min(GROUND_BURST_MAX, Math.ceil(result.radius * GROUND_BURST_PER_METRE));
     renderer.emit(material.debris === "clods" ? "dust" : material.debris, result.point, [0, 1, 0], Math.max(2, size), Math.min(4, 1 + result.radius * 4));
     if (result.radius > GROUND_DUST_RADIUS) renderer.emit("dust", result.point, [0, 1, 0], size, 1.4);
-    playSound(impactKey(def), result.point, Math.min(1, 0.25 + result.radius));
+    playSound(impactKey(def), result.point, Math.min(1, 0.25 + result.radius), impactSoundKeys(material.id, def));
   };
   terrain.onDeform((region) => renderer.wakeRegion(region.x, region.z, region.radius));
   const groundImpl = createTerrainImpl(terrain, { id: GROUND_ID, name: t("ground.name"), onBlow: showGroundBlow });
@@ -5005,7 +5548,7 @@ function createTestRoom(options) {
   });
   let pending = [];
   const eventListeners = /* @__PURE__ */ new Set();
-  const listeners = { spawn: /* @__PURE__ */ new Set(), tool: /* @__PURE__ */ new Set(), grab: /* @__PURE__ */ new Set(), throw: /* @__PURE__ */ new Set(), event: eventListeners, camera: /* @__PURE__ */ new Set() };
+  const listeners = { spawn: /* @__PURE__ */ new Set(), tool: /* @__PURE__ */ new Set(), grab: /* @__PURE__ */ new Set(), throw: /* @__PURE__ */ new Set(), event: eventListeners, camera: /* @__PURE__ */ new Set(), footfall: /* @__PURE__ */ new Set() };
   const fire = (type, data) => {
     for (const fn of listeners[type] ?? []) fn(data);
   };
@@ -5142,6 +5685,15 @@ function createTestRoom(options) {
     floorAt: terrain.heightAt,
     start: arena.playerStart,
     crouchKeys: options.crouch?.keys,
+    onSlam: (event) => slamPlayer(event),
+    onFeet: (event) => {
+      const at = player.position;
+      if (event.type === "jump") bodySounds.jump(at);
+      else {
+        bodySounds.land(surfaceUnderFeet(), event.speed, at);
+        action("landing_player", t("act.player_land", { speed: num(event.speed, 1) }), { data: { speedMs: Math.round(event.speed * 100) / 100, surface: surfaceUnderFeet() } });
+      }
+    },
     hooks: {
       primaryDown: () => {
         useHeld = true;
@@ -5213,7 +5765,11 @@ function createTestRoom(options) {
       return piece;
     },
     dragSound: (objectId, point, volume) => playSound(dragSoundKey(world.materials.get(heaviestMaterial(objectId) ?? "")), point, volume),
-    hitSound: (objectId, point) => playSound(impactKey(world.materials.get(heaviestMaterial(objectId) ?? "")), point, 0.5),
+    hitSound: (objectId, point) => {
+      const material = heaviestMaterial(objectId) ?? "";
+      const def = world.materials.get(material);
+      playSound(impactKey(def), point, 0.5, impactSoundKeys(material, def, "blunt"));
+    },
     onEvent: (ev) => {
       const vars = { name: ev.name, kg: num(ev.massKg, 0) };
       action(`push_${ev.type}`, t(`act.push_${ev.type}`, vars), { objectId: ev.objectId, itemId: entryOf(ev.objectId)?.so.itemId, data: { massKg: Math.round(ev.massKg * 10) / 10 } });
@@ -5303,7 +5859,13 @@ function createTestRoom(options) {
     isLocked: (objectId, part) => lockedLeaves.has(`${objectId}\0*`) || lockedLeaves.has(`${objectId}\0${part}`),
     nameOf,
     impactKey: (objectId, part) => impactKey(world.materials.get(world.part(objectId, part)?.material ?? heaviestMaterial(objectId) ?? "")),
+    leafSound: (objectId, part, moment) => {
+      const spec = specs.get(objectId);
+      return spec?.tags?.includes("vehicle") ? vehicleLeafKey(spec, part, moment) : void 0;
+    },
     sound: playSound,
+    // a vehicle's doors, hood and lid have their own sounds in the vehicle bank (game-vehicles-three), not those of the house
+    leafFoley: (objectId, part, slides2) => specs.get(objectId)?.tags?.includes("vehicle") ? null : leafFoleyOf(entryOf(objectId)?.item?.sounds, part, impactKey(world.materials.get(world.part(objectId, part)?.material ?? heaviestMaterial(objectId) ?? "")), slides2),
     onEvent: (ev) => {
       const vars = { name: ev.name, percent: Math.round(ev.opening * 100) };
       action(`door_${ev.type}`, t(`act.door_${ev.type}`, vars), { objectId: ev.objectId, itemId: entryOf(ev.objectId)?.so.itemId, part: ev.part, data: { opening: Math.round(ev.opening * 1e3) / 1e3, ...ev.by ? { by: ev.by } : {} } });
@@ -5318,12 +5880,23 @@ function createTestRoom(options) {
     for (const p of st?.parts ?? []) if (p.status !== "broken" && p.status !== "melted" && p.status !== "ashes") m += p.mass;
     return m;
   };
+  const batchers = /* @__PURE__ */ new Map();
+  const batchObject = (objectId, root) => {
+    let meshes = 0;
+    let unbatched = false;
+    root.traverse((object) => {
+      if (object.isMesh) meshes++;
+      if (UNBATCHED_OWNERS.test(object.userData.kitOrigin?.owner ?? "")) unbatched = true;
+    });
+    if (!unbatched && meshes >= BATCH_MIN_MESHES) batchers.set(objectId, createStaticBatcher(THREE, root, { budgetMs: BATCH_BUDGET_MS }));
+  };
   const registerEntry = (objectId, itemId, root, spec, name, parts, item, arenaObject, movable) => {
     specs.set(objectId, spec);
     renderer.bind(objectId, root, parts ? { parts } : void 0);
     const so = { objectId, itemId, root, movable };
     const e = { so, item, name, arena: arenaObject, fluidOffset: [0, 0, 0], uses: [], piece: null, last: [root.position.x, root.position.y, root.position.z], velocity: [0, 0, 0] };
     entries.set(objectId, e);
+    batchObject(objectId, root);
     if (movable) {
       e.piece = renderer.makePiece(objectId, { mass: Math.max(0.2, massOfObject(objectId)) });
       rendererPieces.set(objectId, e.piece);
@@ -5591,6 +6164,8 @@ function createTestRoom(options) {
     dropTree(e.so.root);
     dropTree(inner);
     entries.delete(id);
+    batchers.get(id)?.dispose();
+    batchers.delete(id);
     doors.forget(id);
     rendererPieces.delete(id);
     specs.delete(id);
@@ -5689,7 +6264,7 @@ function createTestRoom(options) {
     lastImpact.clear();
     addArena();
     standFootprints();
-    timeScale = 1;
+    scheduler.timeScale = 1;
     fastForward = false;
     walkPlan = null;
   };
@@ -5699,6 +6274,37 @@ function createTestRoom(options) {
   let avatar = null;
   let cameraMode = options.cameraMode ?? "first";
   let crouchForced = false;
+  let downForced = false;
+  const playerMass = options.playerMass ?? bodyMass(1.75);
+  const SLAM_REACH = PLAYER_RADIUS + 0.35;
+  const SLAM_SHOULDER = 1.3;
+  const slamPlayer = (event) => {
+    const [x, feet, z] = player.position;
+    const energy = 0.5 * playerMass * event.speed * event.speed;
+    let hit = null;
+    if (event.against === "obstacle") {
+      const from = [x, feet + ((player.knocked?.lying ?? 0) > 0.5 ? 0.3 : SLAM_SHOULDER), z];
+      hit = rayWorld(from, event.direction, SLAM_REACH);
+      if (hit) world.hitPart(hit.object, hit.part, { type: "blunt", point: hit.point, direction: event.direction, energy, radius: 0.2, ...hit.normal ? { normal: hit.normal } : {} });
+    }
+    bodySounds.slam(event.speed, [x, feet + 0.5, z]);
+    action("player_slammed", t(event.against === "obstacle" ? "act.player_slammed" : "act.player_fell", { speed: num(event.speed, 1), what: hit ? nameOf(hit.object) : "" }), {
+      ...hit ? { objectId: hit.object, part: hit.part } : {},
+      data: { against: event.against, speed: event.speed, energy, ...hit ? { object: hit.object, part: hit.part } : {} }
+    });
+  };
+  const knockPlayer = (event) => {
+    if (seating.seat) return;
+    const feet = [player.x, player.feet, player.z];
+    const reach = world.blastReach(event.point, [feet[0], feet[1] + KNOCK_CHEST, feet[2]], event.source ? { ignore: [event.source] } : {});
+    const knock = knockOf({ point: event.point, energy: event.energy, radius: event.radius, reach }, feet, playerMass, options.blastShove);
+    if (!knock) return;
+    player.knock(knock);
+    const speed = Math.hypot(knock.velocity[0], knock.velocity[1], knock.velocity[2]);
+    action(knock.down ? "player_knocked_down" : "player_shoved", t(knock.down ? "act.knocked_down" : "act.player_shoved", { speed: num(speed, 1), reach: num(reach * 100, 0) }), {
+      data: { speed, reach, down: knock.down, source: event.source }
+    });
+  };
   const avatarState = { speed: 0, running: false, crouch: false, down: false, armed: false, pitch: 0 };
   let feetPrev = null;
   let armedForced = null;
@@ -5754,6 +6360,7 @@ function createTestRoom(options) {
     feetPrev = [x, z];
     avatarState.running = !player.crouching && (player.keys.has("ShiftLeft") || player.keys.has("ShiftRight"));
     avatarState.crouch = crouchForced || player.crouching || push.isBent;
+    avatarState.down = downForced || Boolean(player.knocked?.down || (player.knocked?.lying ?? 0) > 0.5);
     avatarState.armed = armedForced ?? tool.def.action.kind === "firearm";
     avatarState.pitch = player.pitch;
     avatarState.holding = heldPiece !== null;
@@ -5826,14 +6433,18 @@ function createTestRoom(options) {
     if (!avatar?.reach) return;
     avatar.reach(targets, { camera, keepOutside: { contact: (origin, direction, maxDistance) => rayWorld(origin, direction, maxDistance)?.distance ?? null } });
   };
+  const thirdEuler = new THREE.Euler(0, 0, 0, "YXZ");
   const applyThirdView = () => {
     if (!thirdActive()) return () => void 0;
     const home = camera.position.clone();
+    const turn = camera.quaternion.clone();
     const pose = thirdPose(0);
     camera.position.set(pose.position[0], pose.position[1], pose.position[2]);
+    if (player.knocked) camera.quaternion.setFromEuler(thirdEuler.set(player.pitch, player.yaw, 0, "YXZ"));
     camera.updateMatrixWorld(true);
     return () => {
       camera.position.copy(home);
+      camera.quaternion.copy(turn);
       camera.updateMatrixWorld(true);
     };
   };
@@ -5890,6 +6501,28 @@ function createTestRoom(options) {
     }
   };
   const rayWorld = (o, d, max) => withoutHeld(() => world.raycast(o, d, max));
+  const surfaceUnderFeet = () => {
+    const [x, feet, z] = player.position;
+    const under = rayWorld([x, feet + 0.15, z], [0, -1, 0], 0.5);
+    if (under && under.object !== GROUND_ID) {
+      const material = world.state(under.object)?.parts.find((p) => p.id === under.part)?.material;
+      if (material) return surfaceOfMaterial(material);
+    }
+    return surfaceOfMaterial(terrain.columnAt(x, z).material);
+  };
+  const strides = createStrideCounter();
+  let feetAt = null;
+  const stepFeet = (dt) => {
+    const [x, , z] = player.position;
+    const moved = feetAt && dt > 0 ? Math.hypot(x - feetAt[0], z - feetAt[1]) : 0;
+    feetAt = [x, z];
+    if (dt <= 0 || seating.seat) return;
+    const gait = player.running ? "run" : "walk";
+    const foot = avatar?.footfall ? avatar.footfall() : moved / dt > MAX_STRIDE_SPEED ? null : strides.advance(moved, gait);
+    if (!foot || !player.grounded) return;
+    emitHost({ type: "footfall", foot, surface: surfaceUnderFeet(), gait, position: player.position });
+    fire("footfall", { foot, gait, time: simTime });
+  };
   let rng = 12345;
   const rnd = () => {
     rng = rng * 1664525 + 1013904223 >>> 0;
@@ -6008,6 +6641,12 @@ function createTestRoom(options) {
     ui?.toast(msg);
   };
   const toolName = (id = toolId) => arsenal.name(id);
+  const toolDef = (id) => arsenal.weapons.get(id);
+  const blowTarget = (r) => {
+    const part = world.state(r.object)?.parts.find((p) => p.id === r.part);
+    if (!part || !(world.materials.get(part.material)?.tags ?? []).includes("body")) return "object";
+    return /head|face|jaw|skull|neck/.test(r.part) ? "head" : "body";
+  };
   const hitWhere = (r) => {
     const p = world.part(r.object, r.part);
     return `${nameOf(r.object)} \u203A ${r.part}${p ? ` (${dStrings.materialNames[p.material] ?? p.material})` : ""}`;
@@ -6017,6 +6656,7 @@ function createTestRoom(options) {
     renderer.impulse(objectId, [dir[0] * momentum, dir[1] * momentum, dir[2] * momentum], point);
   };
   const shotRay = new THREE.Raycaster();
+  shotRay.layers.enableAll();
   const LIQUID_SLOWING = 0.25;
   const SHOT_GRIP = 0.3;
   const shotPush = (s, objectId, results, fallback) => {
@@ -6186,7 +6826,15 @@ function createTestRoom(options) {
       action("melee", t("act.melee.miss", { weapon: w }), { data: { weapon: id } });
       return;
     }
-    world.hitPart(r.object, r.part, { ...useToHit(u, r.point, r.normal), source: "player" });
+    const hit = useToHit(u, r.point, r.normal);
+    const result = world.hitPart(r.object, r.part, { ...hit, source: "player" });
+    if (!result.events.some((e) => MARK_EVENTS.has(e.type))) {
+      const material = world.part(r.object, r.part)?.material ?? heaviestMaterial(r.object) ?? "";
+      const def = world.materials.get(material);
+      playSound(impactKey(def), r.point, Math.min(0.8, 0.25 + u.energy / 400), impactSoundKeys(material, def, hit.type));
+    }
+    const blow = blowOfTool(id, toolDef(id)?.category ?? "");
+    if (blow) bodySounds.hit(blow, blowTarget(r), r.point, u.energy);
     pushPiece(r.object, u.direction, 2 * u.energy / 6, r.point);
     action("melee", t("act.melee.hit", { weapon: w, energy: num(u.energy, 0), where: hitWhere(r), dist: num(r.distance, 1) }), {
       objectId: r.object,
@@ -6227,6 +6875,10 @@ function createTestRoom(options) {
       comboNext = (stepIndex + 1) % combo.steps.length;
       comboAt = simTime;
     }
+    const blow = blowOfTool(id, toolDef(id)?.category ?? "");
+    const lead = blow ? swingLead(blow) : 0;
+    const swing = blow ? () => bodySounds.swing(blow, player.position) : void 0;
+    if (swing && (seconds === null || seconds <= lead)) swing();
     if (clip === void 0 || seconds === null) {
       if (leg) {
         legAim();
@@ -6241,6 +6893,7 @@ function createTestRoom(options) {
     strikes.push({
       key: id,
       remaining: seconds,
+      ...swing && seconds > lead ? { swing, lead } : {},
       land: () => {
         if (leg) legAim();
         else aim();
@@ -6250,7 +6903,13 @@ function createTestRoom(options) {
   };
   const stepStrikes = (dt) => {
     if (strikes.length === 0) return;
-    for (const strike of strikes) strike.remaining -= dt;
+    for (const strike of strikes) {
+      strike.remaining -= dt;
+      if (strike.swing && strike.remaining <= (strike.lead ?? 0)) {
+        strike.swing();
+        delete strike.swing;
+      }
+    }
     const landed = strikes.filter((strike) => strike.remaining <= 0);
     strikes = strikes.filter((strike) => strike.remaining > 0);
     for (const strike of landed) strike.land();
@@ -6364,26 +7023,27 @@ function createTestRoom(options) {
     aim();
     const cat = tool.def.category;
     if (cat === "hand") {
-      if (strikes.some((strike) => strike.key === "hand" || strike.key === "fists")) return;
+      if (strikes.some((strike) => strike.key === "hand" || strike.key === "fists")) return "cooldown";
       strikeUse({ kind: "melee", damage: "blunt", energy: 25, radius: 0.1, reach: 0.8, origin: [aimO[0], aimO[1], aimO[2]], direction: [aimD[0], aimD[1], aimD[2]] }, "hand");
-      return;
+      return "ok";
     }
-    if (strikes.some((strike) => strike.key === toolId)) return;
+    if (strikes.some((strike) => strike.key === toolId)) return "cooldown";
     const res = tool.trigger([aimO[0], aimO[1], aimO[2]], [aimD[0], aimD[1], aimD[2]], dt, held, "player");
     flushEvents(toolId, tool, res.recoil);
     if (res.status === "empty") {
       if (!tool.reloading && tool.reserve > 0) startReload();
       say(t(tool.reloading ? "hud.reloading" : "hud.empty"));
-      return;
+      return res.status;
     }
     if (res.status !== "ok") {
       if (res.status === "reloading") say(t("hud.reloading"));
       else if (res.status === "no_fuel") say(t("hud.no_fuel"));
       else if (res.status === "fault" && res.fault) say(t("hud.fault", { fault: t(`fault.${res.fault}`) }));
       else if (res.status === "safe") say(t("hud.safe"));
-      return;
+      return res.status;
     }
     applyUses(res, dt);
+    return res.status;
   };
   const applyUses = (res, dt) => {
     if (res.shots.length) fireShots(res.shots, res.recoil);
@@ -6485,8 +7145,9 @@ function createTestRoom(options) {
     heldTilt = 0;
   };
   const handUse = () => {
-    if (heldPiece) grab();
-    else useTool(FIXED_DT, false);
+    if (!heldPiece) return useTool(FIXED_DT, false);
+    grab();
+    return "ok";
   };
   const grab = () => {
     if (push.active) return false;
@@ -6529,7 +7190,9 @@ function createTestRoom(options) {
     heldYaw = 0;
     heldTilt = 0;
     heldVel[0] = heldVel[1] = heldVel[2] = 0;
+    playSound(pickupSoundOf(heldEntry?.item?.sounds, world.materials.get(heaviestMaterial(r.object) ?? "")), r.point, Math.min(1, 0.45 + kg * 0.1));
     action("grab", t("act.grab", { name: heldName, kg: num(kg, 1) }), { objectId: r.object, itemId: entryOf(r.object)?.so.itemId, data: { massKg: Math.round(kg * 10) / 10 } });
+    playSound(impactKey(world.materials.get(heaviestMaterial(r.object) ?? "")).replace("impact_", "grab_"), v3(piece.root.getWorldPosition(tmpV)), 0.8);
     fire("grab", { held: true, objectId: r.object });
     return true;
   };
@@ -6542,6 +7205,7 @@ function createTestRoom(options) {
     releaseHeld();
     piece.velocity = [0, 0, 0];
     renderer.impulse(id, [aimD[0] * speed * piece.mass, (aimD[1] * speed + 1.2) * piece.mass, aimD[2] * speed * piece.mass]);
+    playSound("item_throw", [piece.root.position.x, piece.root.position.y, piece.root.position.z], Math.min(1, 0.3 + speed * 0.04));
     action("throw", t("act.throw", { name, speed: num(speed, 1) }), { objectId: id, itemId: entryOf(id)?.so.itemId, data: { speedMs: speed, massKg: piece.mass } });
     fire("throw", { objectId: id, speed });
     return true;
@@ -6653,6 +7317,7 @@ function createTestRoom(options) {
     e.opened = true;
     if (e.containerId) fluids.open(e.containerId);
     seal.open?.(wrapped.get(e.so.root) ?? e.so.root);
+    playSound(openSoundOf(e.item?.sounds, world.materials.get(heaviestMaterial(e.so.objectId) ?? "")), v3(e.so.root.getWorldPosition(tmpV)), 0.7);
     const tool2 = opener.tool ? catalogMap.get(opener.tool)?.name ?? (arsenal.weapons.has(opener.tool) ? toolName(opener.tool) : opener.tool) : void 0;
     action("open_seal", tool2 ? t("act.open_with", { name: e.name, tool: tool2 }) : t("act.open_by_hand", { name: e.name }), { objectId: e.so.objectId, itemId: e.so.itemId, data: { tool: opener.tool ?? "hand" } });
     return true;
@@ -6701,17 +7366,28 @@ function createTestRoom(options) {
     if (consuming && c.closed) fluids.open(e.containerId);
     useItemPlayer = createItemUse(fluids, e.containerId, def);
     useItemName = def.id;
+    useSoundIn = 0;
     if (eating) useLiters = c.liters;
     action("use_item", t("act.use_item", { name: e.name, use: S.text[`use.${def.id}`] ?? def.id }), { objectId: e.so.objectId, itemId: e.so.itemId, data: { use: def.id } });
     return true;
   };
   let useLiters = null;
+  let useSoundIn = 0;
   const updateItemUse = (dt) => {
     if (!useItemPlayer) return;
     const e = heldEntry;
     const c = e?.containerId ? fluids.container(e.containerId) : void 0;
     const before = c?.liters;
     useItemPlayer.update(dt);
+    const useSound = e && useLiters !== null ? useSoundOf(e.item?.sounds, useItemName) : void 0;
+    if (useSound && e) {
+      useSoundIn -= dt;
+      const now = e.containerId ? fluids.container(e.containerId)?.liters : void 0;
+      if (useSoundIn <= 0 && before !== void 0 && now !== void 0 && now < before) {
+        playSound(useSound, v3(e.so.root.getWorldPosition(tmpV)), 0.6);
+        useSoundIn = USE_SOUND_EVERY;
+      }
+    }
     const seal = e?.item?.seal;
     twisting = null;
     if (e && seal?.openUse === useItemName && !e.opened) {
@@ -6921,7 +7597,9 @@ function createTestRoom(options) {
     if (!loadout.includes(weaponId)) loadout.push(weaponId);
     setTool(weaponId);
   };
+  let hudAimHit;
   const inspectTarget = () => {
+    if (hudAimHit !== void 0) return hudAimHit;
     aim();
     return rayWorld(aimO, aimD, 14);
   };
@@ -6999,13 +7677,64 @@ function createTestRoom(options) {
       distance: r.distance
     };
   };
-  let timeScale = 1;
   let fastForward = false;
   let hudAcc = 1;
   let metricsAcc = 0;
   let ownsLoop = false;
+  let moduleFrameCount = 0;
+  const headlessErrors = /* @__PURE__ */ new Map();
+  const loggedErrors = /* @__PURE__ */ new Set();
+  let headlessDepth = 0;
+  const reportFrameError = (error, system) => {
+    if (headlessDepth > 0) {
+      if (!headlessErrors.has(system.id)) headlessErrors.set(system.id, error);
+      return;
+    }
+    if (loggedErrors.has(system.id)) return;
+    loggedErrors.add(system.id);
+    console.error(`test-room: ${system.id} (${system.phase}) threw`, error);
+  };
+  const runHeadless = (run) => {
+    headlessDepth++;
+    try {
+      run();
+    } catch (error) {
+      headlessErrors.clear();
+      throw error;
+    } finally {
+      headlessDepth--;
+    }
+    if (headlessDepth > 0 || headlessErrors.size === 0) return;
+    const errors = [...headlessErrors.values()];
+    headlessErrors.clear();
+    throw errors.length === 1 ? errors[0] : new AggregateError(errors, `${errors.length} systems threw in one frame`);
+  };
+  const scheduler = createScheduler({ maxFrameSeconds: 0.05, budgetMs: options.frameBudgetMs ?? 8, onError: reportFrameError });
+  const audioQueue = audio?.deferredQueue?.();
+  if (audioQueue) scheduler.budget.register(audioQueue, DEFERRED_PRIORITY[DEFERRED_QUEUE_ID.AUDIO_VOICES]);
+  scheduler.budget.register(renderer.deferredQueue(), DEFERRED_PRIORITY[DEFERRED_QUEUE_ID.DESTRUCTION_EVENTS]);
   const roomMetricIds = options.metrics === false ? [] : options.metrics ?? ROOM_METRICS;
   const roomMetrics = createRoomMetrics({ gl, destruction: renderer, fluids: fluidView, effects: vfx.world, ids: roomMetricIds, blast: () => lastBlast });
+  const MEMORY_CLEARS = 4;
+  const memoryWatch = createMemoryWatch({
+    clears: MEMORY_CLEARS,
+    read: () => {
+      const memory = gl.info?.memory;
+      const heap = heapMB();
+      return memory ? { geometries: memory.geometries, textures: memory.textures, ...heap === void 0 ? {} : { heapMB: heap } } : void 0;
+    }
+  });
+  clearListeners.add(() => {
+    const verdict = memoryWatch.cleared(activeBench ?? void 0);
+    if (!verdict) return;
+    if (!verdict.leaking) {
+      ui?.alert(null);
+      return;
+    }
+    const text = t("memory.leak", { geometries: verdict.grew.geometries, textures: verdict.grew.textures, clears: MEMORY_CLEARS });
+    log.add({ channel: "event", type: "memory_leak", text, data: { ...verdict.after, grew: verdict.grew } });
+    ui?.alert(`\u26A0 ${text}`);
+  });
   let qualityName = quality;
   const syncContainers = (sdt) => {
     const drinkingHeld = useItemPlayer !== null && (useItemName === "drink" || useItemName === "sip" || useItemName === "chug");
@@ -7031,7 +7760,6 @@ function createTestRoom(options) {
       if (part && part.liters !== void 0 && Math.abs(part.liters - c.liters) > 1e-4) world.setLiters(host2.objectId, e.fluidPart, c.liters);
     }
   };
-  let paused = false;
   let walkPlan = null;
   const stepWalk = (dt) => {
     if (!walkPlan) return;
@@ -7040,8 +7768,7 @@ function createTestRoom(options) {
     walkPlan.remaining -= dt;
     if (walkPlan.remaining <= 1e-9) walkPlan = null;
   };
-  const stepSim = (dt) => {
-    if (paused) return;
+  const simulateBeforeModules = (dt) => {
     simTime += dt;
     stepWalk(dt);
     stepStrikes(dt);
@@ -7057,6 +7784,7 @@ function createTestRoom(options) {
     }
     syncLiters();
     renderer.update(dt);
+    destructionSound?.update(dt);
     for (const e of entries.values()) e.follower?.update?.();
     terrainView.sync(camera.position);
     showGroundFire(dt);
@@ -7073,7 +7801,8 @@ function createTestRoom(options) {
       const look = camera.getWorldDirection(listenerDirection);
       audio.setListener({ position: [camera.position.x, camera.position.y, camera.position.z], yaw: Math.atan2(-look.x, -look.z) });
     }
-    for (const update2 of frameListeners) update2(dt);
+  };
+  const simulateAfterModules = (dt) => {
     for (const tr of tracers) {
       if (tr.life > 0) {
         tr.life -= dt;
@@ -7082,7 +7811,7 @@ function createTestRoom(options) {
     }
     flush();
   };
-  const update = (dt) => {
+  const updateInput = (dt, isPaused) => {
     if (!ownsLoop) roomMetrics.frame(dt);
     frameStamp++;
     seating.update();
@@ -7091,31 +7820,33 @@ function createTestRoom(options) {
       pushByKey = false;
       push.end();
     }
-    push.step(paused ? 0 : dt);
-    doors.step(paused ? 0 : dt);
-    if (!paused) kickLight(dt);
-    if (!paused) pushByPlayer(dt);
+    push.step(isPaused ? 0 : dt);
+    doors.step(isPaused ? 0 : dt);
+    if (!isPaused) kickLight(dt);
+    if (!isPaused) pushByPlayer(dt);
     else player.takeWish();
-    stepAvatar(paused ? 0 : dt);
+    stepAvatar(isPaused ? 0 : dt);
+    stepFeet(isPaused ? 0 : dt);
     if (tiltKey || heldTilt > 0) {
       heldTilt = Math.max(0, Math.min(2.4, heldTilt + (tiltKey ? 2.2 : -3) * dt));
     }
-    if ((useHeld || useFirst) && !paused && !push.active) {
+    if ((useHeld || useFirst) && !isPaused && !push.active) {
       if (tool.def.category === "hand") {
         if (useFirst) handUse();
       } else if (useHeld) useTool(dt, !useFirst);
       useFirst = false;
     }
-    if (!paused) followHeld(dt);
-    stepSim(dt * timeScale);
+    if (!isPaused) followHeld(dt);
+  };
+  const updatePresent = (dt) => {
     reachAvatar();
     if (progress && simTime - progress.at > 0.25) progress = null;
+    ui?.flushLog();
     hudAcc += dt;
     if (hudAcc >= 0.1 && ui) {
       hudAcc = 0;
       ui.hud(hudState());
     }
-    ui?.flushLog();
     metricsAcc += dt;
     if (metricsAcc >= METRICS_INTERVAL_S && ui) {
       metricsAcc = 0;
@@ -7123,6 +7854,14 @@ function createTestRoom(options) {
     }
   };
   const hudState = () => {
+    hudAimHit = inspectTarget();
+    try {
+      return readHudState();
+    } finally {
+      hudAimHit = void 0;
+    }
+  };
+  const readHudState = () => {
     const page = Math.floor(toolIndex / 10);
     const slots = loadout.slice(page * 10, page * 10 + 10).map((id) => arsenal.name(id));
     const ammo = tool.def.action.kind === "firearm" ? `${tool.ammo}/${tool.capacity}${tool.reserve ? ` \xB7 ${tool.reserve}` : ""}` : tool.def.action.kind === "hand" ? "" : tool.def.action.kind === "melee" || tool.def.action.kind === "tool" ? "" : `${num(tool.ammo, 0)}`;
@@ -7140,7 +7879,7 @@ function createTestRoom(options) {
       inspect: inspectInfo(),
       animations: animationsOf(),
       locked: player.locked,
-      timeScale,
+      timeScale: scheduler.timeScale,
       fast: fastForward,
       tap: isTapOn(),
       combo: combo ? comboOn : null,
@@ -7292,6 +8031,8 @@ function createTestRoom(options) {
       const value = sampled[id];
       return value === void 0 ? [] : [{ id, name: t(`metric.${id}`), text: num(value, id === "frame_ms" ? 1 : 0) }];
     });
+    const leak = memoryWatch.last;
+    if (leak?.leaking) room2.push({ id: "memory_leak", name: "\u26A0", text: t("memory.leak_short", { geometries: leak.grew.geometries, textures: leak.grew.textures, clears: MEMORY_CLEARS }) });
     const values = moduleMetrics();
     const declared = (activeBench ? benches.get(activeBench)?.metrics : void 0) ?? [];
     const module = declared.map((metric) => {
@@ -7307,11 +8048,11 @@ function createTestRoom(options) {
     ui.metrics(metricRows());
   };
   const hostListeners = /* @__PURE__ */ new Set();
-  const frameListeners = /* @__PURE__ */ new Set();
   const listenerDirection = new THREE.Vector3();
   const environment = options.environment ?? createEnvironmentBus();
   const audioSink = audio ? createAudioSink(audio) : void 0;
   function emitHost(event) {
+    if (event.type === "explosion") knockPlayer(event);
     for (const listener of hostListeners) listener(event);
   }
   function flushEvents(id, state, recoil) {
@@ -7360,12 +8101,21 @@ function createTestRoom(options) {
     scene,
     camera,
     locale,
+    ...graphics ? { graphics: graphics.host } : {},
     ...audioSink ? { audio: audioSink } : {},
     environment,
     groundAt,
+    // the terrain's material where the floor is the top; a table or a counter answers undefined (the module's default)
+    surfaceAt: (x, z) => Math.max(sceneryTopAt(x, z), restingTopAt(x, z)) > terrain.heightAt(x, z) ? void 0 : terrain.columnAt(x, z).material,
     effects: vfx,
+    particleLimit: () => options.debris?.particleLimit ?? DEFAULT_PARTICLE_LIMIT,
+    lights,
+    pools,
     loading,
+    addView: (view) => moduleViews.add(view),
+    setViewCamera: (view) => moduleViews.setMain(view ?? null),
     ...options.blastShove ? { blastShove: options.blastShove } : {},
+    blastReach: (point, target, ignore) => world.blastReach(point, target, ignore ? { ignore } : {}),
     tool: () => ({
       weapon: toolId,
       category: tool.def.category,
@@ -7415,9 +8165,9 @@ function createTestRoom(options) {
       hostListeners.add(listener);
       return () => hostListeners.delete(listener);
     },
-    onFrame(update2) {
-      frameListeners.add(update2);
-      return () => frameListeners.delete(update2);
+    defer: (queue, queueOptions) => scheduler.budget.register(queue, queueOptions),
+    onFrame(update, frameOptions) {
+      return scheduler.add((ctx) => update(ctx.dt), { phase: frameOptions?.phase ?? "lateSimulate", order: frameOptions?.order ?? 0, id: `module.frame#${moduleFrameCount++}` });
     },
     holdFrame: () => bodyHoldFrame(),
     reachFor(reach) {
@@ -7475,46 +8225,47 @@ function createTestRoom(options) {
     return r.ok ? store : null;
   };
   const LIGHTS_CHECK_MS = 250;
-  const pinnedPrograms = /* @__PURE__ */ new WeakSet();
-  const pinPrograms = () => {
-    for (const program of gl.info?.programs ?? []) {
-      if (pinnedPrograms.has(program)) continue;
-      pinnedPrograms.add(program);
-      program.usedTimes++;
+  const materialsOf = (group) => {
+    const found = /* @__PURE__ */ new Set();
+    group.traverse((object) => {
+      const material = object.material;
+      for (const each of Array.isArray(material) ? material : material ? [material] : []) found.add(each);
+    });
+    return [...found];
+  };
+  const probeOf = (id, adapter) => ({
+    id,
+    build() {
+      const probe = adapter.warmUpProbes();
+      const group = probe.group;
+      return { group, materials: materialsOf(group), dispose: () => probe.dispose() };
     }
+  });
+  warmup.register(probeOf("destruction", renderer));
+  warmup.register(probeOf("vfx", vfx));
+  warmup.register(probeOf("fluids", fluidView));
+  warmup.register(spriteProbes(THREE));
+  const warmedEffect = (id) => {
+    let handle = null;
+    return {
+      id: `vfx:${id}`,
+      play() {
+        handle = vfx.play({ effect: id, point: [0, 0.1, -4], direction: [0, 1, 0], normal: [0, 1, 0] });
+      },
+      step: (dt) => vfx.update(dt),
+      stop() {
+        if (handle !== null) vfx.stop(handle);
+        vfx.world.clear();
+        vfx.update(0);
+      }
+    };
   };
+  const catalogIds = vfx.catalog?.() ?? [];
+  for (const id of [...EXPLOSIVE_EFFECT_IDS, ...catalogIds.filter((id2) => /fire|flame/i.test(id2)).slice(0, 1)]) if (catalogIds.includes(id)) warmup.registerEffect(warmedEffect(id));
+  let warmedUp = false;
   const warmUp = () => {
-    const probes = [renderer.warmUpProbes(), vfx.warmUpProbes(), fluidView.warmUpProbes()];
-    const groups = probes.map((probe) => probe.group);
-    const spriteMap = new THREE.DataTexture(new Uint8Array([255, 255, 255, 255]), 1, 1);
-    spriteMap.needsUpdate = true;
-    const spriteProbes = [true, false].map((fog) => {
-      const probe = new THREE.Sprite(new THREE.SpriteMaterial({ map: spriteMap, transparent: true, fog }));
-      probe.frustumCulled = false;
-      return probe;
-    });
-    groups.push(...spriteProbes);
-    scene.add(...groups);
-    gl.render(scene, camera);
-    pinPrograms();
-    scene.remove(...groups);
-    for (const probe of probes) probe.dispose();
-    for (const probe of spriteProbes) probe.material.dispose();
-    spriteMap.dispose();
-  };
-  const warmUpEffects = () => {
-    const ids = vfx.catalog?.() ?? [];
-    const flames = ids.filter((id) => /fire|flame/i.test(id)).slice(0, 1);
-    gl.compile(scene, camera);
-    const handles = ["m67", ...flames].filter((id) => ids.includes(id)).map((effect) => vfx.play({ effect, point: [0, 0.1, -4], direction: [0, 1, 0], normal: [0, 1, 0] }));
-    for (let i = 0; i < 3; i++) {
-      vfx.update(0.02);
-      gl.render(scene, camera);
-    }
-    for (const h of handles) if (h !== null) vfx.stop(h);
-    vfx.world.clear();
-    vfx.update(0);
-    gl.render(scene, camera);
+    warmup.warmUp(gl, scene, camera, { lights, fogStates: WARMED_FOG_STATES, materials: pools.materials.registeredMaterials?.() ?? [] });
+    warmedUp = true;
   };
   const loadModule = (mod) => {
     const report = { module: mod.id, items: [], scenarios: [], ok: true, problems: [] };
@@ -7539,6 +8290,7 @@ function createTestRoom(options) {
         impl: ti.impl,
         animations: ti.animations,
         seats: ti.seats,
+        sounds: ti.sounds,
         thumbnail: ti.thumbnail,
         thumbnailCredit: ti.thumbnailCredit
       };
@@ -7626,24 +8378,13 @@ function createTestRoom(options) {
   };
   const allScenarios = () => [...extraScenarios];
   let scenarioRunning = false;
-  const step = (seconds) => {
-    const dt = seconds > 6 ? 1 / 30 : FIXED_DT;
-    const n = Math.max(1, Math.round(seconds / dt));
-    for (let i = 0; i < n; i++) {
-      seating.update();
-      player.update(0);
-      push.step(dt);
-      doors.step(dt);
-      followHeld(dt);
-      stepSim(dt);
-    }
-  };
+  const step = (seconds) => runHeadless(() => scheduler.advance(seconds, { dt: seconds > 6 ? 1 / 30 : FIXED_DT }));
   const runScenarios = async (list) => {
     const all = list ?? allScenarios();
     const report = { passed: 0, failed: 0, results: [] };
     scenarioRunning = true;
-    const wasPaused = paused;
-    paused = false;
+    const wasPaused = scheduler.paused;
+    scheduler.resume();
     try {
       for (const sc of all) {
         hardReset();
@@ -7675,7 +8416,7 @@ function createTestRoom(options) {
       }
     } finally {
       scenarioRunning = false;
-      paused = wasPaused;
+      if (wasPaused) scheduler.pause();
       restoreScenery();
     }
     return report;
@@ -7807,19 +8548,25 @@ function createTestRoom(options) {
     useItem,
     use(hold = 0) {
       if (tool.def.category === "hand") {
-        handUse();
+        const status2 = handUse();
         flush();
-        return;
+        return status2;
       }
-      useTool(FIXED_DT, false);
+      const status = useTool(FIXED_DT, false);
       flush();
       let t0 = 0;
       while (t0 < hold) {
         useTool(FIXED_DT, true);
-        stepSim(FIXED_DT);
+        directStep = true;
+        try {
+          runHeadless(() => scheduler.advance(FIXED_DT));
+        } finally {
+          directStep = false;
+        }
         t0 += FIXED_DT;
       }
       releaseTrigger();
+      return status;
     },
     grab,
     throwHeld,
@@ -7835,14 +8582,14 @@ function createTestRoom(options) {
     spawned() {
       return [...entries.values()].filter((e) => !e.arena).map((e) => e.so);
     },
-    update,
+    update: (dt) => runHeadless(() => scheduler.frame(dt, { render: false, exact: true })),
     waitUntilReady(maxSeconds = 5) {
       let waited = 0;
       while (tool.phase && waited < maxSeconds) {
-        update(FIXED_DT);
+        room.update(FIXED_DT);
         waited += FIXED_DT;
       }
-      update(FIXED_DT);
+      room.update(FIXED_DT);
       return waited + FIXED_DT;
     },
     on(type, fn) {
@@ -7859,20 +8606,20 @@ function createTestRoom(options) {
       blastOptions = { ...blastOptions, ...next };
     },
     pause() {
-      paused = true;
+      scheduler.pause();
     },
     resume() {
-      paused = false;
+      scheduler.resume();
     },
     get paused() {
-      return paused;
+      return scheduler.paused;
     },
     walk(to, seconds) {
       walkPlan = seconds > 0 ? { x: to[0], z: to[2], remaining: seconds } : null;
       if (!walkPlan) player.moveBy(to[0] - camera.position.x, to[2] - camera.position.z);
     },
     setSlowMotion(on) {
-      timeScale = on ? 0.25 : 1;
+      scheduler.timeScale = on ? 0.25 : 1;
     },
     setFastForward(on) {
       fastForward = on;
@@ -7888,12 +8635,13 @@ function createTestRoom(options) {
     modules: () => [...modules.values()].map((m) => ({ id: m.id, name: m.name, group: m.group, hasArea: typeof m.area === "function" })),
     openAreaAsync: (area) => loading.busy(t("loading.open_area", { area: areaLabel(area) }), () => openArea(area)),
     loading,
+    graphics: graphics?.controller ?? null,
+    graphicsScreen: graphics?.screen ?? null,
     busy: (label, work, busyOptions) => loading.busy(label, work, busyOptions),
     loadModule,
     warmUp: () => {
       audio?.warmUp();
       warmUp();
-      warmUpEffects();
     },
     animations: animationsOf,
     playAnimation,
@@ -7929,7 +8677,10 @@ function createTestRoom(options) {
         crouchForced = state.crouch;
         avatarState.crouch = state.crouch || player.crouching;
       }
-      if (state.down !== void 0) avatarState.down = state.down;
+      if (state.down !== void 0) {
+        downForced = state.down;
+        avatarState.down = state.down || Boolean(player.knocked?.down);
+      }
       if (state.armed !== void 0) armedForced = state.armed;
     },
     avatarState: () => ({ ...avatarState }),
@@ -7950,6 +8701,9 @@ function createTestRoom(options) {
     get playerPosition() {
       return player.position;
     },
+    get playerKnock() {
+      return player.knocked;
+    },
     sit: (objectId, seatId) => seating.sit(objectId, seatId),
     stand: () => seating.stand(),
     get seat() {
@@ -7965,20 +8719,30 @@ function createTestRoom(options) {
     metrics() {
       return { room: roomMetrics.sample(), module: moduleMetrics() };
     },
+    frameStats: () => scheduler.stats(),
+    lights,
+    webgl: gl,
     dispose() {
       destructionSound?.dispose();
       if (ownAudio) audio?.dispose();
       for (const detach of detachers.values()) detach();
       detachers.clear();
+      moduleViews.dispose();
       for (const store of benches.values()) store.dispose();
       benches.clear();
-      cancelAnimationFrame?.(raf);
+      stopLoop?.();
+      disposePacer?.();
+      scheduler.dispose();
       window.removeEventListener("resize", onResize);
       player.dispose();
       ui?.dispose();
+      graphics?.dispose();
       loading.dispose();
       renderer.dispose();
       vfx.dispose();
+      lights.dispose();
+      pools.materials.dispose();
+      pools.geometries.dispose();
       fluidView.dispose();
       filmBridge.dispose();
       film.dispose();
@@ -8044,6 +8808,7 @@ function createTestRoom(options) {
         }
       },
       quality: qualityName,
+      ...graphics?.screen ? { onGraphics: () => graphics.screen?.open() } : {},
       scenarios: allScenarios,
       onRun: async (sc) => {
         await runScenarios([sc]);
@@ -8077,41 +8842,77 @@ function createTestRoom(options) {
     ui.hud(hudState());
     showBench();
   }
-  let raf = 0;
-  if (ownRenderer && typeof requestAnimationFrame === "function") {
-    let last = performance.now();
-    ownsLoop = true;
+  let directStep = false;
+  scheduler.add(
+    (ctx) => {
+      if (directStep) return;
+      if (!ctx.scripted) return updateInput(ctx.dt, ctx.paused);
+      seating.update();
+      player.update(0);
+      push.step(ctx.dt);
+      doors.step(ctx.dt);
+      followHeld(ctx.dt);
+    },
+    { phase: "input", id: "room.input" }
+  );
+  scheduler.add((ctx) => simulateBeforeModules(ctx.dt), { phase: "lateSimulate", order: -1e3, id: "room.simulate" });
+  scheduler.add((ctx) => simulateAfterModules(ctx.dt), { phase: "lateSimulate", order: 1e3, id: "room.simulate-end" });
+  scheduler.add(
+    (ctx) => {
+      if (ctx.simulated && !ctx.scripted) updatePresent(ctx.realDt);
+    },
+    { phase: "present", id: "room.present" }
+  );
+  scheduler.add((ctx) => lights.present([camera.position.x, camera.position.y, camera.position.z], ctx.realDt), { phase: "present", order: 10, id: "room.lights" });
+  let stopLoop;
+  let disposePacer;
+  if (ownRenderer) {
     let nextLightsCheck = 0;
-    let warmedLights = "";
-    const lightsKey = () => {
-      let key2 = "";
-      scene.traverseVisible((object) => {
-        if (object.isLight) key2 += `${object.type[0]}${object.castShadow ? "s" : ""}`;
-      });
-      return key2;
-    };
-    const loop = (now) => {
-      raf = requestAnimationFrame(loop);
-      if (now >= nextLightsCheck) {
+    let warnedState = "";
+    scheduler.add(
+      (ctx) => {
+        if (ctx.scripted) return;
+        const now = performance.now();
+        if (now < nextLightsCheck) return;
         nextLightsCheck = now + LIGHTS_CHECK_MS;
-        const key2 = lightsKey();
-        if (key2 !== warmedLights) {
-          warmedLights = key2;
-          warmUp();
-        }
-      }
-      const realDelta = (now - last) / 1e3;
-      roomMetrics.frame(realDelta);
-      const dt = Math.min(0.05, realDelta);
-      last = now;
-      if (!scenarioRunning) update(dt);
-      const restoreCamera = room.applyCamera();
-      gl.render(scene, debugView ?? camera);
-      pinPrograms();
-      restoreCamera();
-      roomMetrics.rendered();
-    };
-    raf = requestAnimationFrame(loop);
+        const state = lights.check(gl, scene);
+        if (warmedUp && (state.ok || state.actual === warnedState)) return;
+        warnedState = state.actual;
+        warmUp();
+      },
+      { phase: "render", order: -1e3, id: "room.lights-check" }
+    );
+    const pacer = createFramePacer(typeof gl.getContext === "function" ? gl.getContext() : null, options.framesInFlight === void 0 ? {} : { framesInFlight: options.framesInFlight });
+    disposePacer = () => pacer.dispose();
+    scheduler.add(
+      (ctx) => {
+        if (!ctx.scripted && !pacer.ready()) return;
+        for (const batcher of batchers.values()) batcher.update();
+        const restoreCamera = room.applyCamera();
+        graphics?.beforeRender(camera);
+        gl.render(scene, debugView ?? moduleViews.main(camera));
+        moduleViews.render(scene);
+        graphics?.afterRender();
+        restoreCamera();
+        pacer.submitted();
+        roomMetrics.rendered();
+        if (!ctx.scripted) graphics?.frameEnd();
+      },
+      { phase: "render", id: "room.render" }
+    );
+    try {
+      stopLoop = startLoop(scheduler, {
+        onFrame: (realSeconds) => {
+          graphics?.frameStart();
+          roomMetrics.frame(realSeconds);
+        },
+        skipSimulation: () => scenarioRunning,
+        // the player's frame cap (Gráficos → Limite de FPS)
+        ...graphics ? { minFrameMs: () => graphics.controller.minFrameMs() } : {}
+      });
+      ownsLoop = true;
+    } catch {
+    }
   }
   if (options.initial) {
     for (const [i, id] of options.initial.entries()) spawn(id, [(i - (options.initial.length - 1) / 2) * 1.3, 0, 0.5]);