@adatechnology/game-test-room 0.20.0 → 0.21.0

package/dist/index.js

@@ -1,13 +1,87 @@
 // src/room.ts
 import { createDestruction, JOINT_DEFAULTS, resolveStrings as resolveDestructionStrings } from "@adatechnology/game-destruction";
 import { createAudioEngine, createAudioSink } from "@adatechnology/game-audio";
+import { 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 };
+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, ...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)),
+    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 { createDestructionRenderer, createDestructionSound, dragSoundKey, impactKey, specFromObject3D } from "@adatechnology/game-destruction-three";
 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";
@@ -1187,6 +1261,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 +1475,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 +1516,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 +1538,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 +2088,7 @@ function createNarrator(c) {
 }
 
 // src/player.ts
+var LANDING_MIN_SPEED = 1;
 var EYE = 1.7;
 var PLAYER_RADIUS = 0.3;
 var FOOT = 0.5;
@@ -1911,6 +2115,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] };
@@ -2163,6 +2368,9 @@ function createPlayer(THREE, o) {
     get running() {
       return running;
     },
+    get grounded() {
+      return y <= floorUnder + 1e-3 && vy <= 0;
+    },
     get crouching() {
       return isCrouched();
     },
@@ -2188,13 +2396,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;
         }
       }
@@ -3121,6 +3334,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,8 +3385,11 @@ 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",
@@ -3471,6 +3692,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,8 +3743,11 @@ 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",
@@ -4110,6 +4339,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 +4458,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");
@@ -4461,17 +4692,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 +4933,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);
@@ -4733,7 +4973,14 @@ function createUi(o) {
 
 // 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;
@@ -4801,6 +5048,17 @@ function createTestRoom(options) {
   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 +5104,17 @@ 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 bodySounds = createBodySounds(audio);
   const playSound = (key2, point, volume) => {
     destructionSound?.onSound(key2, point, volume);
     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,
@@ -5005,7 +5268,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 +5405,14 @@ function createTestRoom(options) {
     floorAt: terrain.heightAt,
     start: arena.playerStart,
     crouchKeys: options.crouch?.keys,
+    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;
@@ -5318,12 +5589,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 +5873,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 +5973,7 @@ function createTestRoom(options) {
     lastImpact.clear();
     addArena();
     standFootprints();
-    timeScale = 1;
+    scheduler.timeScale = 1;
     fastForward = false;
     walkPlan = null;
   };
@@ -5890,6 +6174,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 +6314,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 +6329,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) => {
@@ -6187,6 +6500,8 @@ function createTestRoom(options) {
       return;
     }
     world.hitPart(r.object, r.part, { ...useToHit(u, r.point, r.normal), source: "player" });
+    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 +6542,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 +6560,7 @@ function createTestRoom(options) {
     strikes.push({
       key: id,
       remaining: seconds,
+      ...swing && seconds > lead ? { swing, lead } : {},
       land: () => {
         if (leg) legAim();
         else aim();
@@ -6250,7 +6570,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 +6690,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 +6812,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;
@@ -6999,13 +7327,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 +7410,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 +7418,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);
@@ -7073,7 +7450,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 +7460,7 @@ function createTestRoom(options) {
     }
     flush();
   };
-  const update = (dt) => {
+  const updateInput = (dt, isPaused) => {
     if (!ownsLoop) roomMetrics.frame(dt);
     frameStamp++;
     seating.update();
@@ -7091,23 +7469,25 @@ 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;
     hudAcc += dt;
@@ -7140,7 +7520,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 +7672,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,7 +7689,6 @@ 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;
@@ -7360,10 +7741,16 @@ 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,
     ...options.blastShove ? { blastShove: options.blastShove } : {},
     tool: () => ({
@@ -7415,9 +7802,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 +7862,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: [] };
@@ -7626,24 +8014,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 +8052,7 @@ function createTestRoom(options) {
       }
     } finally {
       scenarioRunning = false;
-      paused = wasPaused;
+      if (wasPaused) scheduler.pause();
       restoreScenery();
     }
     return report;
@@ -7807,19 +8184,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 +8218,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 +8242,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 +8271,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,
@@ -7965,6 +8349,9 @@ function createTestRoom(options) {
     metrics() {
       return { room: roomMetrics.sample(), module: moduleMetrics() };
     },
+    frameStats: () => scheduler.stats(),
+    lights,
+    webgl: gl,
     dispose() {
       destructionSound?.dispose();
       if (ownAudio) audio?.dispose();
@@ -7972,13 +8359,19 @@ function createTestRoom(options) {
       detachers.clear();
       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 +8437,7 @@ function createTestRoom(options) {
         }
       },
       quality: qualityName,
+      ...graphics?.screen ? { onGraphics: () => graphics.screen?.open() } : {},
       scenarios: allScenarios,
       onRun: async (sc) => {
         await runScenarios([sc]);
@@ -8077,41 +8471,76 @@ 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 ?? camera);
+        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]);