@adatechnology/game-test-room 0.2.0 → 0.4.0

package/dist/index.js

@@ -4,7 +4,7 @@ import { createDestructionRenderer, specFromObject3D } from "@adatechnology/game
 import { createArsenal, DEFAULT_LOADOUT } from "@adatechnology/game-weapons";
 import { createFluids, createItemUse, ITEM_USES, resolveStrings as resolveFluidStrings } from "@adatechnology/game-fluids";
 import { createFluidRenderer } from "@adatechnology/game-fluids-three";
-import { checkAnimation, checkDestructible, checkSpec } from "@adatechnology/game-contracts";
+import { checkAnimation, checkBench, checkDestructible, checkSpec } from "@adatechnology/game-contracts";
 
 // src/items.ts
 import { buildFrame } from "@adatechnology/game-destruction";
@@ -219,6 +219,21 @@ var en = {
     "ui.animations": "Animations",
     "ui.animations_aim": "Aim at an item or hold it to see its animations.",
     "ui.animations_none": "This item brings no animations.",
+    "mod.bench_ok": "{name}: bench ok ({controls} controls, {layers} layers, {metrics} metrics)",
+    "mod.bench_fail": "{name}: bench broken: {problems}",
+    "mod.metric_failed": '{name}: metric "{metric}" threw and shows n/a: {error}',
+    "mod.listener_failed": "{name}: a bench listener threw: {error}",
+    "ui.bench": "Bench",
+    "ui.layers": "Layers",
+    "ui.metrics": "Counters",
+    "metric.fps": "FPS",
+    "metric.frame_ms": "ms/frame",
+    "metric.draw_calls": "Draw calls",
+    "metric.triangles": "Triangles",
+    "metric.objects": "Objects",
+    "metric.fragments": "Fragments",
+    "metric.particles": "Particles",
+    "metric.decals": "Decals",
     "act.spawn": "Spawned {name} at x {x} \xB7 z {z}",
     "act.clear": "Cleared the room",
     "act.reset": "Repaired every object",
@@ -234,6 +249,15 @@ var en = {
     "act.heat.air": "{weapon}: nothing in range",
     "act.throw.grenade": "{weapon}: thrown, fuse {fuse} s",
     "act.throw.molotov": "{weapon}: thrown, breaks on impact",
+    "act.launch": "{weapon}: launched, arms after {arm} m",
+    "act.place": "{weapon}: charge set down, waits for {triggers}",
+    "act.tripwire": "{weapon}: {who} crossed the trip wire",
+    "act.dud": "{weapon}: hit before arming ({distance} m), did not explode",
+    "act.backblast": "{weapon}: blast behind the tube, {radius} m, {n} objects in the cone, {player} on the shooter",
+    "act.blast_player": "{weapon}: you are in the {zone} zone, {distance} m away (stun {stun} s)",
+    "hud.no_charges": "No charge set down waits for the remote detonator",
+    "blast.zone.lethal": "lethal",
+    "blast.zone.injury": "injury",
     "act.explode": "{weapon}: exploded, {energy} J within {radius} m, {n} objects in range",
     "act.molotov_fire": "{weapon}: fire on the ground, radius {radius} m for {seconds} s",
     "act.tool.none": "{weapon}: nothing in reach",
@@ -259,6 +283,15 @@ var en = {
     "hud.reloading": "Reloading...",
     "hud.empty": "Empty",
     "hud.no_fuel": "Out of fuel",
+    "hud.fault": "Jammed ({fault}): press X to clear",
+    "hud.safe": "Safety on: press B",
+    "hud.clearing": "Clearing the jam...",
+    "hud.safety_on": "Safety on",
+    "hud.safety_off": "Safety off",
+    "fault.misfire": "misfire",
+    "fault.stovepipe": "stovepipe",
+    "fault.double_feed": "double feed",
+    "fault.failure_to_extract": "failure to extract",
     "hud.nothing_to_grab": "Nothing to grab here",
     "hud.cannot_grab": "{name} cannot be picked up",
     "hud.too_heavy": "{name} is too heavy ({kg} kg)",
@@ -269,7 +302,7 @@ var en = {
     "hud.throw": "throw",
     "hud.tilt": "tilt (hold)",
     "hud.equip": "equip {weapon}",
-    "ui.help": "Click: look \xB7 WASD: walk \xB7 Shift: run \xB7 Space: jump \xB7 1-0 / wheel: tool \xB7 LMB: use \xB7 E: grab/drop \xB7 G or RMB: throw \xB7 Tab: panels \xB7 Esc: free the mouse",
+    "ui.help": "Click: look \xB7 WASD: walk \xB7 Shift: run \xB7 Space: jump \xB7 1-0 / wheel: tool \xB7 LMB: use \xB7 E: grab/drop \xB7 G or RMB: throw \xB7 R: reload \xB7 Q: fire mode \xB7 X: clear a jam \xB7 B: safety \xB7 Y: detonate charges set down \xB7 Tab: panels \xB7 Esc: free the mouse",
     "ui.log": "Behaviour log",
     "ui.filter.action": "actions",
     "ui.filter.event": "events",
@@ -511,6 +544,21 @@ var ptBR = {
     "ui.animations": "Anima\xE7\xF5es",
     "ui.animations_aim": "Mire num item ou segure-o para ver as anima\xE7\xF5es.",
     "ui.animations_none": "Este item n\xE3o traz anima\xE7\xF5es.",
+    "mod.bench_ok": "{name}: bancada ok ({controls} controles, {layers} camadas, {metrics} contadores)",
+    "mod.bench_fail": "{name}: bancada quebrada: {problems}",
+    "mod.metric_failed": '{name}: o contador "{metric}" lan\xE7ou erro e mostra n/a: {error}',
+    "mod.listener_failed": "{name}: um ouvinte da bancada lan\xE7ou erro: {error}",
+    "ui.bench": "Bancada",
+    "ui.layers": "Camadas",
+    "ui.metrics": "Contadores",
+    "metric.fps": "FPS",
+    "metric.frame_ms": "ms/quadro",
+    "metric.draw_calls": "Chamadas de desenho",
+    "metric.triangles": "Tri\xE2ngulos",
+    "metric.objects": "Objetos",
+    "metric.fragments": "Fragmentos",
+    "metric.particles": "Part\xEDculas",
+    "metric.decals": "Decalques",
     "act.spawn": "Criou {name} em x {x} \xB7 z {z}",
     "act.clear": "Limpou a sala",
     "act.reset": "Consertou todos os objetos",
@@ -526,6 +574,15 @@ var ptBR = {
     "act.heat.air": "{weapon}: nada ao alcance",
     "act.throw.grenade": "{weapon}: arremessada, pavio de {fuse} s",
     "act.throw.molotov": "{weapon}: arremessado, quebra no impacto",
+    "act.launch": "{weapon}: disparado, arma depois de {arm} m",
+    "act.place": "{weapon}: carga posta, espera {triggers}",
+    "act.tripwire": "{weapon}: {who} cruzou o fio",
+    "act.dud": "{weapon}: bateu antes de armar ({distance} m), n\xE3o explodiu",
+    "act.backblast": "{weapon}: sopro atr\xE1s do tubo, {radius} m, {n} objetos no cone, {player} no atirador",
+    "act.blast_player": "{weapon}: voc\xEA est\xE1 na zona {zone}, a {distance} m (atordoado {stun} s)",
+    "hud.no_charges": "Nenhuma carga posta espera o detonador",
+    "blast.zone.lethal": "letal",
+    "blast.zone.injury": "de ferimento",
     "act.explode": "{weapon}: explodiu, {energy} J em {radius} m, {n} objetos ao alcance",
     "act.molotov_fire": "{weapon}: fogo no ch\xE3o, raio de {radius} m por {seconds} s",
     "act.tool.none": "{weapon}: nada ao alcance",
@@ -551,6 +608,15 @@ var ptBR = {
     "hud.reloading": "Recarregando...",
     "hud.empty": "Sem muni\xE7\xE3o",
     "hud.no_fuel": "Sem combust\xEDvel",
+    "hud.fault": "Travou ({fault}): aperte X para destravar",
+    "hud.safe": "Trava ligada: aperte B",
+    "hud.clearing": "Destravando...",
+    "hud.safety_on": "Trava ligada",
+    "hud.safety_off": "Trava desligada",
+    "fault.misfire": "nega",
+    "fault.stovepipe": "chamin\xE9",
+    "fault.double_feed": "dupla alimenta\xE7\xE3o",
+    "fault.failure_to_extract": "falha de extra\xE7\xE3o",
     "hud.nothing_to_grab": "Nada para pegar aqui",
     "hud.cannot_grab": "{name} n\xE3o d\xE1 para pegar",
     "hud.too_heavy": "{name} \xE9 pesado demais ({kg} kg)",
@@ -561,7 +627,7 @@ var ptBR = {
     "hud.throw": "arremessar",
     "hud.tilt": "inclinar (segurar)",
     "hud.equip": "equipar {weapon}",
-    "ui.help": "Clique: olhar \xB7 WASD: andar \xB7 Shift: correr \xB7 Espa\xE7o: pular \xB7 1-0 / roda: ferramenta \xB7 bot\xE3o esquerdo: usar \xB7 E: pegar/soltar \xB7 G ou bot\xE3o direito: arremessar \xB7 Tab: pain\xE9is \xB7 Esc: soltar o mouse",
+    "ui.help": "Clique: olhar \xB7 WASD: andar \xB7 Shift: correr \xB7 Espa\xE7o: pular \xB7 1-0 / roda: ferramenta \xB7 bot\xE3o esquerdo: usar \xB7 E: pegar/soltar \xB7 G ou bot\xE3o direito: arremessar \xB7 R: recarregar \xB7 Q: modo de tiro \xB7 X: destravar \xB7 B: trava \xB7 Y: detonar cargas postas \xB7 Tab: pain\xE9is \xB7 Esc: soltar o mouse",
     "ui.log": "Registro de comportamento",
     "ui.filter.action": "a\xE7\xF5es",
     "ui.filter.event": "eventos",
@@ -1122,6 +1188,494 @@ function createArena(THREE, size, scene) {
   };
 }
 
+// src/bench.ts
+var snap = (control, value) => {
+  const clamped = Math.min(control.max, Math.max(control.min, value));
+  if (!control.step) return clamped;
+  const stepped = control.min + Math.round((clamped - control.min) / control.step) * control.step;
+  return Number(Math.min(control.max, stepped).toFixed(10));
+};
+function fitValue(control, value) {
+  if (control.kind === "number") return typeof value === "number" && Number.isFinite(value) ? snap(control, value) : void 0;
+  if (control.kind === "boolean") return typeof value === "boolean" ? value : void 0;
+  if (control.kind === "choice") return typeof value === "string" && control.options.some((option) => option.id === value) ? value : void 0;
+  return void 0;
+}
+var fromText = (control, text) => {
+  if (control.kind === "number") return text.trim() === "" ? Number.NaN : Number(text);
+  if (control.kind === "boolean") return text === "1" ? true : text === "0" ? false : void 0;
+  return text;
+};
+var toText = (value) => typeof value === "boolean" ? value ? "1" : "0" : String(value);
+function encodeBenchState(controls, layers) {
+  const pairs = [];
+  for (const control of controls) if (control.value !== void 0) pairs.push(`${control.id}=${encodeURIComponent(toText(control.value))}`);
+  for (const layer of layers) pairs.push(`${layer.id}=${layer.on ? "1" : "0"}`);
+  return pairs.join(";");
+}
+function decodeBenchState(encoded, controls, layers) {
+  const out = /* @__PURE__ */ new Map();
+  for (const pair of encoded.split(";")) {
+    const at = pair.indexOf("=");
+    if (at <= 0) continue;
+    const id = pair.slice(0, at);
+    let text;
+    try {
+      text = decodeURIComponent(pair.slice(at + 1));
+    } catch {
+      continue;
+    }
+    const control = controls.find((c) => c.id === id);
+    if (control) {
+      const value = fitValue(control, fromText(control, text));
+      if (value !== void 0) out.set(id, value);
+      continue;
+    }
+    if (layers.some((layer) => layer.id === id) && (text === "1" || text === "0")) out.set(id, text === "1");
+  }
+  return out;
+}
+function createBenchStore(module, locale, onListenerError) {
+  const declared = { controls: module.controls?.(locale) ?? [], layers: module.layers?.(locale) ?? [], metrics: module.metrics?.(locale) ?? [] };
+  const controls = declared.controls.map((control) => ({ ...control, disabled: false }));
+  const values = /* @__PURE__ */ new Map();
+  for (const control of controls) if (control.kind !== "action") values.set(control.id, control.default);
+  const layers = new Map(declared.layers.map((layer) => [layer.id, layer.default !== false]));
+  const listeners = /* @__PURE__ */ new Set();
+  const watchers = /* @__PURE__ */ new Set();
+  const emit = (change) => {
+    for (const listener of listeners) {
+      try {
+        listener(change);
+      } catch (error) {
+        onListenerError?.(error);
+      }
+    }
+  };
+  const changed = () => {
+    for (const watcher of watchers) watcher();
+  };
+  const controlOf = (id) => controls.find((control) => control.id === id);
+  const store = {
+    moduleId: module.id,
+    metrics: declared.metrics,
+    declared,
+    controls: () => controls.map((control) => ({ ...control, value: values.get(control.id) })),
+    layers: () => declared.layers.map((layer) => ({ ...layer, on: layers.get(layer.id) === true })),
+    value: (id) => values.get(id),
+    layer: (id) => layers.get(id) === true,
+    set(id, value) {
+      const control = controlOf(id);
+      if (!control || control.disabled) return false;
+      const fitted = fitValue(control, value);
+      if (fitted === void 0) return false;
+      values.set(id, fitted);
+      emit({ kind: "control", id, value: fitted });
+      changed();
+      return true;
+    },
+    setLayer(id, on) {
+      if (!layers.has(id)) return false;
+      layers.set(id, on);
+      emit({ kind: "layer", id, on });
+      changed();
+      return true;
+    },
+    act(id) {
+      const control = controlOf(id);
+      if (!control || control.kind !== "action" || control.disabled) return false;
+      emit({ kind: "action", id });
+      return true;
+    },
+    encode: () => encodeBenchState(store.controls(), store.layers()),
+    onChange(listener) {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    },
+    watch(listener) {
+      watchers.add(listener);
+      return () => watchers.delete(listener);
+    },
+    patch(id, patch) {
+      const index = controls.findIndex((control2) => control2.id === id);
+      if (index < 0) return;
+      let control = controls[index];
+      if (patch.hidden !== void 0) control = { ...control, hidden: patch.hidden };
+      if (patch.disabled !== void 0) control = { ...control, disabled: patch.disabled };
+      if (patch.options && control.kind === "choice" && patch.options.length > 0) {
+        control = { ...control, options: [...patch.options] };
+        const offered = control.options;
+        if (!offered.some((option) => option.id === values.get(id))) values.set(id, offered[0].id);
+      }
+      controls[index] = control;
+      if (patch.value !== void 0) {
+        const fitted = fitValue(control, patch.value);
+        if (fitted !== void 0) values.set(id, fitted);
+      }
+      changed();
+    },
+    sendInitial() {
+      for (const control of controls) {
+        const value = values.get(control.id);
+        if (value !== void 0) emit({ kind: "control", id: control.id, value });
+      }
+      for (const layer of declared.layers) emit({ kind: "layer", id: layer.id, on: layers.get(layer.id) === true });
+      changed();
+    },
+    restore(encoded) {
+      for (const [id, value] of decodeBenchState(encoded, controls, declared.layers)) {
+        if (typeof value === "boolean" && layers.has(id)) layers.set(id, value);
+        else values.set(id, value);
+      }
+    },
+    dispose() {
+      listeners.clear();
+      watchers.clear();
+    }
+  };
+  return store;
+}
+
+// src/explosives.ts
+import { backblastEffect, blastEffect, createExplosiveBody, tripwireSegment } from "@adatechnology/game-weapons";
+
+// src/segment-box.ts
+var segmentTouchesBox = (from, to, min, max) => {
+  let near = 0;
+  let far = 1;
+  for (let axis = 0; axis < 3; axis++) {
+    const start = from[axis];
+    const delta = to[axis] - start;
+    const low = min[axis];
+    const high = max[axis];
+    if (Math.abs(delta) < 1e-12) {
+      if (start < low || start > high) return false;
+      continue;
+    }
+    const entering = (low - start) / delta;
+    const leaving = (high - start) / delta;
+    near = Math.max(near, Math.min(entering, leaving));
+    far = Math.min(far, Math.max(entering, leaving));
+    if (near > far) return false;
+  }
+  return true;
+};
+
+// src/explosives.ts
+var CONE_BLAST_RADIUS = 0.5;
+var toArray = (vector) => [vector.x, vector.y, vector.z];
+function createExplosives(context) {
+  const { THREE, scene, camera, world, renderer, arsenal, translate, format, action } = context;
+  const projectiles = [];
+  const meshes = [];
+  const up = new THREE.Vector3(0, 1, 0);
+  const clear = () => {
+    projectiles.length = 0;
+    for (const mesh of meshes) mesh.removeFromParent();
+    meshes.length = 0;
+  };
+  const addMesh = (geometry, color, metalness, at) => {
+    const mesh = new THREE.Mesh(geometry, new THREE.MeshStandardMaterial({ color, roughness: 0.6, metalness }));
+    mesh.castShadow = true;
+    mesh.position.set(at[0], at[1], at[2]);
+    scene.add(mesh);
+    meshes.push(mesh);
+    return mesh;
+  };
+  const remove = (projectile) => {
+    for (const extra of projectile.attached ?? []) {
+      extra.removeFromParent();
+      const extraAt = meshes.indexOf(extra);
+      if (extraAt >= 0) meshes.splice(extraAt, 1);
+    }
+    projectile.mesh.removeFromParent();
+    const meshAt = meshes.indexOf(projectile.mesh);
+    if (meshAt >= 0) meshes.splice(meshAt, 1);
+    const at = projectiles.indexOf(projectile);
+    if (at >= 0) projectiles.splice(at, 1);
+  };
+  const throwUse = (use) => {
+    const isMolotov = !!use.fire;
+    const isRocket = use.trigger === "impact" && (use.armDistance ?? 0) > 0;
+    const geometry = isRocket ? new THREE.CylinderGeometry(0.04, 0.04, 0.5, 8) : isMolotov ? new THREE.CylinderGeometry(0.035, 0.04, 0.2, 8) : new THREE.SphereGeometry(0.045, 8, 6);
+    const mesh = addMesh(geometry, isMolotov ? 3897915 : isRocket ? 7041116 : 4936480, isMolotov ? 0 : 0.4, use.origin);
+    projectiles.push({
+      mesh,
+      pos: new THREE.Vector3(use.origin[0], use.origin[1], use.origin[2]),
+      vel: new THREE.Vector3(use.velocity[0], use.velocity[1], use.velocity[2]),
+      weapon: context.toolId(),
+      fuse: use.fuse,
+      burstOnImpact: isMolotov && use.fuse <= 0,
+      energy: use.energy,
+      radius: use.radius,
+      fire: use.fire,
+      age: 0,
+      ...use.explosive !== void 0 ? { body: createExplosiveBody(use, arsenal.explosives, arsenal.rules.explosives), aligned: isRocket } : {}
+    });
+    const key = isRocket ? "act.launch" : isMolotov ? "act.throw.molotov" : "act.throw.grenade";
+    action(isRocket ? "launch_projectile" : "throw_projectile", translate(key, { weapon: context.toolName(), fuse: format(use.fuse, 1), arm: format(use.armDistance ?? 0, 0) }), {
+      data: { weapon: context.toolId(), fuse: use.fuse, explosive: use.explosive }
+    });
+  };
+  const placementPoint = (use) => {
+    const hit = context.withoutHeld(() => world.raycast(use.origin, use.direction, 3));
+    if (hit) return [hit.point[0] + hit.normal[0] * 0.03, hit.point[1] + hit.normal[1] * 0.03, hit.point[2] + hit.normal[2] * 0.03];
+    const x = use.origin[0] + use.direction[0] * 2;
+    const z = use.origin[2] + use.direction[2] * 2;
+    return [x, context.groundAt(x, z) + 0.03, z];
+  };
+  const markerAt = (at) => {
+    const marker = new THREE.Group();
+    marker.name = "charge_marker";
+    const stake = new THREE.Mesh(new THREE.CylinderGeometry(0.01, 0.01, 0.4, 6), new THREE.MeshStandardMaterial({ color: 9136957, roughness: 0.8 }));
+    stake.position.y = 0.2;
+    const flag = new THREE.Mesh(new THREE.ConeGeometry(0.06, 0.12, 4), new THREE.MeshStandardMaterial({ color: 16738816, emissive: 16724736, emissiveIntensity: 0.4 }));
+    flag.position.y = 0.46;
+    marker.add(stake, flag);
+    marker.position.set(at[0] + 0.12, at[1] - 0.03, at[2]);
+    scene.add(marker);
+    meshes.push(marker);
+    return marker;
+  };
+  const wireLine = (from, to) => {
+    const geometry = new THREE.BufferGeometry().setFromPoints([new THREE.Vector3(...from), new THREE.Vector3(...to)]);
+    const line = new THREE.Line(geometry, new THREE.LineBasicMaterial({ color: 15262920 }));
+    line.name = "charge_wire";
+    scene.add(line);
+    meshes.push(line);
+    return line;
+  };
+  const touching = (wire) => context.bodies().filter((body) => segmentTouchesBox(wire.from, wire.to, toArray(body.box.min), toArray(body.box.max))).map((body) => body.id);
+  const placeUse = (use) => {
+    const at = placementPoint(use);
+    const placed = { ...use, origin: at };
+    const body = createExplosiveBody(placed, arsenal.explosives, arsenal.rules.explosives);
+    if (!body) return;
+    const mesh = addMesh(new THREE.BoxGeometry(0.18, 0.06, 0.1), use.explosive === "claymore" ? 5597999 : 12757112, 0.1, at);
+    mesh.rotation.y = Math.atan2(use.direction[0], use.direction[2]);
+    const attached = [markerAt(at)];
+    const segment = tripwireSegment(placed);
+    const projectile = { mesh, pos: new THREE.Vector3(at[0], at[1], at[2]), vel: new THREE.Vector3(), weapon: context.toolId(), fuse: 0, burstOnImpact: false, energy: use.energy, radius: use.radius, age: 0, body, placed: true, attached };
+    if (segment) {
+      const wire = { from: segment.from, to: segment.to, letThrough: /* @__PURE__ */ new Set() };
+      for (const id of touching(wire)) wire.letThrough.add(id);
+      attached.push(wireLine(segment.from, segment.to));
+      projectile.wire = wire;
+    }
+    projectiles.push(projectile);
+    action("place_charge", translate("act.place", { weapon: context.toolName(), triggers: use.triggers.join("/") || "-" }), { data: { weapon: context.toolId(), explosive: use.explosive, triggers: [...use.triggers], point: at, ...segment ? { wire: segment } : {} } });
+  };
+  const backblastUse = (use) => {
+    renderer.emit("smoke", use.origin, use.direction, 14, use.radius);
+    let reached = 0;
+    for (const object of context.objects()) if (backblastEffect(use, toArray(object.position)) > 0) reached++;
+    const onPlayer = backblastEffect(use, toArray(camera.position));
+    action("backblast", translate("act.backblast", { weapon: context.toolName(), radius: format(use.radius, 0), n: reached, player: format(onPlayer, 2) }), {
+      data: { weapon: context.toolId(), radius: use.radius, halfAngleDeg: use.halfAngleDeg, objects: reached, onPlayer }
+    });
+  };
+  const surfaceProbe = (from, to) => {
+    const dx = to[0] - from[0];
+    const dy = to[1] - from[1];
+    const dz = to[2] - from[2];
+    const length = Math.hypot(dx, dy, dz);
+    if (length < 1e-6) return null;
+    const direction = [dx / length, dy / length, dz / length];
+    const ray = context.withoutHeld(() => world.raycast(from, direction, length + 0.03));
+    let best = ray && ray.distance <= length + 0.03 ? { point: ray.point, normal: ray.normal, ground: ray.normal[1] > 0.7, at: ray.distance } : null;
+    const floor = context.groundAt(to[0], to[2]) + 0.045;
+    if (to[1] < floor) {
+      const point = [to[0], floor, to[2]];
+      const at = Math.hypot(point[0] - from[0], point[1] - from[1], point[2] - from[2]);
+      if (!best || at < best.at) best = { point, normal: [0, 1, 0], ground: true, at };
+    }
+    return best ? { point: best.point, normal: best.normal, ground: best.ground } : null;
+  };
+  const mostExposedPoint = (box2, detonation) => {
+    const { min, max } = box2;
+    const candidates = [toArray(box2.getCenter(new THREE.Vector3())), toArray(box2.clampPoint(new THREE.Vector3(...detonation.point), new THREE.Vector3()))];
+    for (const x of [min.x, max.x]) for (const y of [min.y, max.y]) for (const z of [min.z, max.z]) candidates.push([x, y, z]);
+    let best;
+    for (const point of candidates) {
+      const effect = blastEffect(detonation, point);
+      if (effect.zone !== "none" && (!best || effect.falloff > best.falloff)) best = { point, falloff: effect.falloff };
+    }
+    return best?.point;
+  };
+  const coneBlast = (detonation) => {
+    let reached = 0;
+    for (const object of context.objects()) {
+      const box2 = new THREE.Box3().setFromObject(object);
+      if (box2.isEmpty()) box2.expandByPoint(object.position);
+      const at = mostExposedPoint(box2, detonation);
+      if (!at) continue;
+      reached += world.explode(at, detonation.energy * blastEffect(detonation, at).falloff, CONE_BLAST_RADIUS, "player").length;
+    }
+    return reached;
+  };
+  const detonate = (projectile, detonation) => {
+    const weaponName = context.toolName(projectile.weapon);
+    const reach = Math.max(detonation.injuryRadius, detonation.lethalRadius);
+    const reached = detonation.energy <= 0 ? 0 : detonation.cone ? coneBlast(detonation) : world.explode(detonation.point, detonation.energy, reach, "player").length;
+    if (detonation.energy > 0) renderer.explode(detonation.point, detonation.energy, reach);
+    if (detonation.stunSeconds !== void 0) renderer.emit("flash", detonation.point, [0, 1, 0], 1, 1);
+    const onPlayer = blastEffect(detonation, toArray(camera.position));
+    action("explode", translate("act.explode", { weapon: weaponName, energy: format(detonation.energy, 0), radius: format(reach, 1), n: reached }), {
+      data: { weapon: projectile.weapon, explosive: detonation.explosive, cause: detonation.cause, energyJ: detonation.energy, radius: reach, point: detonation.point, player: onPlayer.zone, stunSeconds: onPlayer.stunSeconds }
+    });
+    if (onPlayer.zone !== "none") {
+      action("blast_player", translate("act.blast_player", { weapon: weaponName, zone: translate(`blast.zone.${onPlayer.zone}`), distance: format(onPlayer.distance, 1), stun: format(onPlayer.stunSeconds, 1) }), { data: { ...onPlayer } });
+    }
+    context.emitHost({ type: "explosion", source: projectile.weapon, point: detonation.point, energy: detonation.energy, radius: reach, cause: detonation.cause });
+    if (detonation.fire) context.startFire(projectile.weapon, detonation.point, detonation.fire, detonation.cause === "impact");
+  };
+  const detonateBare = (projectile, isImpact) => {
+    detonate(projectile, {
+      explosive: projectile.weapon,
+      cause: isImpact ? "impact" : "timer",
+      point: toArray(projectile.pos),
+      direction: [0, 1, 0],
+      at: projectile.age,
+      energy: projectile.energy,
+      lethalRadius: 0,
+      injuryRadius: projectile.radius,
+      noise: 0,
+      destructionLevel: 0,
+      ...projectile.fire ? { fire: projectile.fire } : {}
+    });
+  };
+  const detonateCharges = () => {
+    let count = 0;
+    for (const projectile of [...projectiles]) {
+      if (!projectile.placed || !projectile.body) continue;
+      const event = projectile.body.trigger("remote");
+      if (event?.type !== "detonate") continue;
+      detonate(projectile, event.detonation);
+      remove(projectile);
+      count++;
+    }
+    if (count === 0) context.say(translate("hud.no_charges"));
+    return count;
+  };
+  const stepBody = (projectile, body, dt) => {
+    const events = body.step(dt, surfaceProbe);
+    projectile.pos.set(body.position[0], body.position[1], body.position[2]);
+    projectile.mesh.position.copy(projectile.pos);
+    if (projectile.aligned && body.velocity[0] ** 2 + body.velocity[1] ** 2 + body.velocity[2] ** 2 > 1e-6) {
+      projectile.mesh.quaternion.setFromUnitVectors(up, new THREE.Vector3(body.velocity[0], body.velocity[1], body.velocity[2]).normalize());
+    } else if (!projectile.placed) projectile.mesh.rotation.x += dt * 8;
+    for (const event of events) {
+      if (event.type === "dud") action("dud", translate("act.dud", { weapon: context.toolName(projectile.weapon), distance: format(body.travelled, 1) }), { data: { weapon: projectile.weapon, point: event.point } });
+      else if (event.type === "detonate") detonate(projectile, event.detonation);
+    }
+  };
+  const flyBare = (projectile, dt) => {
+    const { gravity } = arsenal.rules.explosives;
+    let isBurst = false;
+    projectile.vel.y -= gravity * dt;
+    const speed = projectile.vel.length();
+    const step = speed * dt;
+    if (step > 1e-6) {
+      const direction = [projectile.vel.x / speed, projectile.vel.y / speed, projectile.vel.z / speed];
+      const hit = context.withoutHeld(() => world.raycast(toArray(projectile.pos), direction, step + 0.05));
+      if (hit && hit.distance <= step + 0.04) {
+        projectile.pos.set(hit.point[0] - direction[0] * 0.03, hit.point[1] - direction[1] * 0.03, hit.point[2] - direction[2] * 0.03);
+        if (projectile.burstOnImpact) isBurst = true;
+        else {
+          const normal = hit.normal;
+          const normalSpeed = projectile.vel.x * normal[0] + projectile.vel.y * normal[1] + projectile.vel.z * normal[2];
+          projectile.vel.x = (projectile.vel.x - 2 * normalSpeed * normal[0]) * 0.35;
+          projectile.vel.y = (projectile.vel.y - 2 * normalSpeed * normal[1]) * 0.35;
+          projectile.vel.z = (projectile.vel.z - 2 * normalSpeed * normal[2]) * 0.35;
+        }
+      } else projectile.pos.addScaledVector(projectile.vel, dt);
+    }
+    const ground = context.groundAt(projectile.pos.x, projectile.pos.z) + 0.045;
+    if (projectile.pos.y < ground) {
+      projectile.pos.y = ground;
+      if (projectile.burstOnImpact) isBurst = true;
+      else {
+        projectile.vel.y = Math.abs(projectile.vel.y) * 0.35;
+        projectile.vel.x *= 0.7;
+        projectile.vel.z *= 0.7;
+      }
+    }
+    return isBurst;
+  };
+  const checkWire = (projectile, body) => {
+    const wire = projectile.wire;
+    if (!wire) return;
+    const crossing = touching(wire);
+    for (const id of [...wire.letThrough]) if (!crossing.includes(id)) wire.letThrough.delete(id);
+    const crosser = crossing.find((id) => !wire.letThrough.has(id));
+    if (crosser === void 0) return;
+    const event = body.trigger("wire");
+    if (event?.type !== "detonate") return;
+    action("tripwire", translate("act.tripwire", { weapon: context.toolName(projectile.weapon), who: crosser }), { data: { weapon: projectile.weapon, body: crosser } });
+    detonate(projectile, event.detonation);
+  };
+  const update = (dt) => {
+    for (let index = projectiles.length - 1; index >= 0; index--) {
+      const projectile = projectiles[index];
+      if (!projectile) continue;
+      projectile.age += dt;
+      if (projectile.body) {
+        if (projectile.wire && !projectile.body.done) checkWire(projectile, projectile.body);
+        stepBody(projectile, projectile.body, dt);
+        if (projectile.body.done || !projectile.placed && projectile.age > 60) remove(projectile);
+        continue;
+      }
+      const isBurst = flyBare(projectile, dt);
+      projectile.mesh.position.copy(projectile.pos);
+      projectile.mesh.rotation.x += dt * 8;
+      projectile.fuse -= dt;
+      if (isBurst || !projectile.burstOnImpact && projectile.fuse <= 0 || projectile.age > 30) {
+        detonateBare(projectile, isBurst);
+        remove(projectile);
+      }
+    }
+  };
+  return { throwUse, placeUse, backblastUse, detonateCharges, update, clear };
+}
+
+// src/host-events.ts
+var NO_RECOIL = [0, 0];
+var durationOf = (phase, id) => phase?.id === id ? { duration: Math.round((phase.end - phase.start) * 1e6) / 1e6 } : {};
+var toHostEvent = (weapon, event, options = {}) => {
+  const { recoil = NO_RECOIL, phase } = options;
+  switch (event.type) {
+    case "draw":
+      return event.phase === "start" ? { type: "tool", weapon, ...durationOf(phase, "draw") } : null;
+    // a launcher spends a round and throws one projectile: the weapon counts none because it is a throw, a host counts the one that leaves
+    case "shot":
+      return { type: "shot", weapon, shots: Math.max(1, event.shots), recoil, rounds: event.rounds, mode: event.mode };
+    case "misfire":
+      return { type: "misfire", weapon };
+    case "reload":
+      return { type: "reload", weapon, phase: event.phase, ...event.phase === "start" ? { kind: event.kind, ...durationOf(phase, "reload") } : {} };
+    case "reload_stage":
+      return { type: "stage", weapon, stage: event.stage };
+    case "feed":
+      return { type: "feed", weapon };
+    case "cycle":
+      return { type: "cycle", weapon, phase: event.phase, ...event.phase === "start" ? durationOf(phase, "cycle") : {} };
+    case "empty":
+      return { type: "empty", weapon };
+    case "mode":
+      return { type: "mode", weapon, mode: event.mode };
+    case "fault":
+      return { type: "fault", weapon, fault: event.fault };
+    case "clear":
+      return { type: "clear", weapon, fault: event.fault, phase: event.phase, ...event.phase === "start" ? durationOf(phase, "clear") : {} };
+    case "safety":
+      return { type: "safety", weapon, on: event.on };
+    case "cook":
+      return { type: "cook", weapon, phase: event.phase, fuse: event.fuse };
+    default:
+      return null;
+  }
+};
+
 // src/log.ts
 var MAX_ENTRIES = 5e3;
 var pad = (n, w = 2) => String(n).padStart(w, "0");
@@ -1250,6 +1804,56 @@ function createLog(options = {}) {
   return log;
 }
 
+// src/metrics.ts
+var ROOM_METRICS = ["fps", "frame_ms", "draw_calls", "triangles", "objects", "fragments", "particles", "decals"];
+var WINDOW_S = 0.5;
+function createRoomMetrics(sources) {
+  const wanted = new Set(sources.ids);
+  const gl = sources.gl;
+  let windowS = 0;
+  let frames = 0;
+  let fps;
+  let frameMs;
+  let calls;
+  let triangles;
+  let ownsRender = false;
+  return {
+    frame(dt) {
+      frames++;
+      windowS += dt;
+      if (windowS < WINDOW_S) return;
+      fps = frames / windowS;
+      frameMs = windowS / frames * 1e3;
+      frames = 0;
+      windowS = 0;
+    },
+    rendered() {
+      ownsRender = true;
+      calls = gl.info?.render?.calls;
+      triangles = gl.info?.render?.triangles;
+    },
+    sample() {
+      const out = {};
+      const put = (id, value) => {
+        if (wanted.has(id) && value !== void 0) out[id] = value;
+      };
+      put("fps", fps);
+      put("frame_ms", frameMs);
+      const render = ownsRender ? { calls, triangles } : gl.info?.render;
+      put("draw_calls", render?.calls);
+      put("triangles", render?.triangles);
+      if (!["objects", "fragments", "particles", "decals"].some((id) => wanted.has(id))) return out;
+      const destruction = sources.destruction.stats();
+      const fluids = sources.fluids.stats();
+      put("objects", destruction.pieces);
+      put("fragments", destruction.fragments);
+      put("particles", destruction.particles + fluids.particles);
+      put("decals", destruction.decals + fluids.stains);
+      return out;
+    }
+  };
+}
+
 // src/narrate.ts
 var SKIP_DAMAGE = /* @__PURE__ */ new Set(["fire", "heat"]);
 function createNarrator(c) {
@@ -1763,7 +2367,7 @@ function createNarrator(c) {
 
 // src/player.ts
 var EYE = 1.7;
-var RADIUS = 0.3;
+var PLAYER_RADIUS = 0.3;
 var WALK = 3.4;
 var RUN = 6.2;
 var JUMP = 4.6;
@@ -1788,8 +2392,8 @@ function createPlayer(THREE, o) {
   };
   apply();
   const blocked = (x, z) => {
-    if (Math.abs(x) > o.limit - RADIUS || Math.abs(z) > o.limit - RADIUS) return true;
-    for (const c of o.colliders) if (x > c[0] - RADIUS && x < c[2] + RADIUS && z > c[1] - RADIUS && z < c[3] + RADIUS) return true;
+    if (Math.abs(x) > o.limit - PLAYER_RADIUS || Math.abs(z) > o.limit - PLAYER_RADIUS) return true;
+    for (const c of o.colliders) if (x > c[0] - PLAYER_RADIUS && x < c[2] + PLAYER_RADIUS && z > c[1] - PLAYER_RADIUS && z < c[3] + PLAYER_RADIUS) return true;
     return false;
   };
   const move = (dx, dz) => {
@@ -2011,6 +2615,7 @@ function makeScenarios(t, num, _locale = "en") {
     sc("steel_through_hole", ({ room, step, expect }) => {
       const id = at(room, "steel_sheet", 0, -4);
       room.setTool("pistol_9mm");
+      room.waitUntilReady();
       look(room, [0, 1.1, -1.5], [0, 1.1, -4]);
       room.use();
       step(0.2);
@@ -2025,6 +2630,7 @@ function makeScenarios(t, num, _locale = "en") {
     sc("concrete_stops_bullet", ({ room, step, expect }) => {
       const id = at(room, "concrete_block", 0, -4);
       room.setTool("pistol_9mm");
+      room.waitUntilReady();
       look(room, [0, 0.5, -1.5], [0, 0.2, -3.8]);
       room.use();
       step(0.2);
@@ -2040,6 +2646,7 @@ function makeScenarios(t, num, _locale = "en") {
     sc("hammer_dents_drum", ({ room, step, expect }) => {
       const id = at(room, "steel_drum", 0, -4);
       room.setTool("hammer");
+      room.waitUntilReady();
       look(room, [0, 0.6, -3.35], [0, 0.5, -4]);
       let swings = 0;
       for (; swings < 8 && (part(room, id, "drum_body")?.dents.length ?? 0) === 0; swings++) {
@@ -2056,6 +2663,7 @@ function makeScenarios(t, num, _locale = "en") {
     sc("glass_shatters", ({ room, step, expect }) => {
       const id = at(room, "glass_pane", 0, -4);
       room.setTool("pistol_9mm");
+      room.waitUntilReady();
       look(room, [0, 1.3, -1.5], [0, 1.05, -4]);
       let shots = 0;
       for (; shots < 10 && part(room, id, "pane")?.status !== "broken"; shots++) {
@@ -2070,6 +2678,7 @@ function makeScenarios(t, num, _locale = "en") {
     sc("shotgun_splinters_crate", ({ room, step, expect }) => {
       const id = at(room, "wooden_crate", 0, -4);
       room.setTool("shotgun_pump_12");
+      room.waitUntilReady();
       look(room, [0, 0.6, -1.8], [0, 0.25, -3.77]);
       let shots = 0;
       const splinters = () => room.log.entries({ type: "fracture", objectId: id }).filter((e) => e.data?.style === "splinter").length;
@@ -2103,6 +2712,7 @@ function makeScenarios(t, num, _locale = "en") {
       const id = at(room, "chair", 0, -4);
       const before = room.renderer.pieces().length;
       room.setTool("kick");
+      room.waitUntilReady();
       let kicks = 0;
       for (; kicks < 8 && room.renderer.pieces().length <= before && part(room, id, "leg_1"); kicks++) {
         const st = room.world.state(id);
@@ -2119,6 +2729,7 @@ function makeScenarios(t, num, _locale = "en") {
     sc("screwdriver_shelf_board", ({ room, step, expect }) => {
       const id = at(room, "shelf", 0, -4);
       room.setTool("screwdriver");
+      room.waitUntilReady();
       look(room, [0, 0.8, -3.5], [0, 0.75, -3.86]);
       const t0 = room.log.entries().length ? room.log.entries().slice(-1)[0].t : 0;
       room.use(5);
@@ -2132,6 +2743,7 @@ function makeScenarios(t, num, _locale = "en") {
     sc("wrong_tool_refused", ({ room, expect }) => {
       const id = at(room, "steel_sheet", 0, -4);
       room.setTool("screwdriver");
+      room.waitUntilReady();
       look(room, [0.2, 1.05, -3.6], [0.34, 1, -4]);
       room.use(0.5);
       const refused = count(room, "tool_refused");
@@ -2141,6 +2753,7 @@ function makeScenarios(t, num, _locale = "en") {
     sc("lighter_burns_crate", ({ room, step, expect }) => {
       const id = at(room, "wooden_crate", 0, -4);
       room.setTool("lighter");
+      room.waitUntilReady();
       look(room, [0, 0.3, -3.65], [0, 0.25, -3.76]);
       room.use(5);
       const lit = anyBurning(room, id);
@@ -2163,6 +2776,7 @@ function makeScenarios(t, num, _locale = "en") {
       const melt0 = part(room, drum2, "drum_body")?.melt ?? 0;
       expect(melt0 === 0 && peak < 1450, t("sc.torch_melts_steel.wood", { peak: num(peak, 0), melt: num(melt0 * 100, 0), crate: yn(anyBurning(room, crate2)) }), { peak });
       room.setTool("cutting_torch");
+      room.waitUntilReady();
       look(room, [-0.15, 0.55, -3.55], [-0.15, 0.5, -3.72]);
       room.use(20);
       const p = part(room, drum2, "drum_body");
@@ -2171,6 +2785,7 @@ function makeScenarios(t, num, _locale = "en") {
     sc("bucket_melts_drips", ({ room, step, expect }) => {
       const id = at(room, "plastic_bucket", 0, -4);
       room.setTool("flamethrower");
+      room.waitUntilReady();
       look(room, [0, 0.5, -2.4], [0, 0.15, -4]);
       room.use(2.5);
       step(10);
@@ -2245,6 +2860,7 @@ function makeScenarios(t, num, _locale = "en") {
     sc("jerrycan_leaks_fuel", ({ room, step, expect }) => {
       const id = at(room, "jerrycan", 0, -3.5);
       room.setTool("pistol_9mm");
+      room.waitUntilReady();
       look(room, [0, 0.4, -1.5], [0, 0.12, -3.43]);
       room.use();
       step(1.5);
@@ -2259,6 +2875,7 @@ function makeScenarios(t, num, _locale = "en") {
       const id = at(room, "jerrycan", 0, -3.5);
       const crate2 = at(room, "wooden_crate", 0.9, -3.2);
       room.setTool("pistol_9mm");
+      room.waitUntilReady();
       look(room, [0, 0.4, -1.5], [0, 0.12, -3.43]);
       room.use();
       step(6);
@@ -2266,6 +2883,7 @@ function makeScenarios(t, num, _locale = "en") {
       expect(!!stain, t("sc.fuel_stain_burns.stain", { stain: yn(!!stain) }));
       if (!stain) return;
       room.setTool("lighter");
+      room.waitUntilReady();
       look(room, [stain.center[0], 0.1, stain.center[2] + 0.06], [stain.center[0], 0, stain.center[2]]);
       room.use(1);
       step(4);
@@ -2301,6 +2919,7 @@ function makeScenarios(t, num, _locale = "en") {
       const before = anyBurning(room, id);
       expect(before, t("sc.extinguisher_puts_out_fire.burning", { burning: yn(before) }));
       room.setTool("extinguisher");
+      room.waitUntilReady();
       look(room, [0, 0.9, -2.2], [0, 0.25, -4]);
       room.use(2.5);
       step(1);
@@ -2320,6 +2939,209 @@ function scenariosFor(locale = "en") {
 }
 var SCENARIOS = scenariosFor("en");
 
+// src/bench-panel.ts
+var SEGMENTED_MAX = 4;
+var mk = (tag, cls, text) => {
+  const e = document.createElement(tag);
+  if (cls) e.className = cls;
+  if (text !== void 0) e.textContent = text;
+  return e;
+};
+var shapeOf = (view) => JSON.stringify([view.title, view.controls.map((c) => ({ ...c, value: void 0 })), view.layers.map((l) => [l.id, l.name])]);
+function createBenchPanel(o) {
+  const { t } = o;
+  const element = mk("div", "tr-panel tr-bench");
+  element.style.display = "none";
+  element.addEventListener("keydown", (e) => e.stopPropagation());
+  const roomLine = mk("div", "sub tr-bench-room");
+  const body = mk("div");
+  const metricTitle = mk("div", "sub", t("ui.metrics"));
+  metricTitle.style.display = "none";
+  const metricList = mk("dl", "tr-metrics");
+  element.append(mk("h3", void 0, t("ui.bench")), roomLine, body, metricTitle, metricList);
+  let shape = "";
+  let hasRoom = false;
+  let hasBench = false;
+  const refreshers = [];
+  const metricNodes = /* @__PURE__ */ new Map();
+  let metricKey = "";
+  const syncDisplay = () => {
+    element.style.display = hasRoom || hasBench ? "" : "none";
+  };
+  const numberControl = (control) => {
+    const wrap = mk("label", "tr-ctl");
+    const input = mk("input");
+    input.type = "range";
+    input.min = String(control.min);
+    input.max = String(control.max);
+    input.step = control.step ? String(control.step) : "any";
+    input.disabled = control.disabled;
+    const reading = mk("output");
+    input.oninput = () => o.onControl(control.id, Number(input.value));
+    wrap.append(mk("span", void 0, control.name), input, reading);
+    refreshers.push((view) => {
+      const value = view.controls.find((c) => c.id === control.id)?.value;
+      if (typeof value !== "number") return;
+      if (Number(input.value) !== value) input.value = String(value);
+      reading.textContent = `${o.num(value, control.step && control.step >= 1 ? 0 : 2)}${control.unit ? ` ${control.unit}` : ""}`;
+    });
+    return wrap;
+  };
+  const booleanControl = (control) => {
+    const wrap = mk("label", "tr-ctl");
+    const box2 = mk("input");
+    box2.type = "checkbox";
+    box2.disabled = control.disabled;
+    box2.onchange = () => o.onControl(control.id, box2.checked);
+    wrap.append(box2, document.createTextNode(` ${control.name}`));
+    refreshers.push((view) => {
+      box2.checked = view.controls.find((c) => c.id === control.id)?.value === true;
+    });
+    return wrap;
+  };
+  const choiceControl = (control) => {
+    const wrap = mk("div", "tr-ctl");
+    wrap.appendChild(mk("span", void 0, control.name));
+    if (control.options.length <= SEGMENTED_MAX) {
+      const group = mk("div", "tr-seg");
+      group.setAttribute("role", "group");
+      const buttons = control.options.map((option) => {
+        const b = mk("button", "tr-btn", option.name);
+        b.type = "button";
+        b.disabled = control.disabled;
+        b.onclick = () => o.onControl(control.id, option.id);
+        group.appendChild(b);
+        return { b, id: option.id };
+      });
+      wrap.appendChild(group);
+      refreshers.push((view) => {
+        const value = view.controls.find((c) => c.id === control.id)?.value;
+        for (const { b, id } of buttons) {
+          b.setAttribute("aria-pressed", String(id === value));
+          b.classList.toggle("on", id === value);
+        }
+      });
+      return wrap;
+    }
+    const select = mk("select");
+    select.disabled = control.disabled;
+    for (const option of control.options) {
+      const op = mk("option", void 0, option.name);
+      op.value = option.id;
+      select.appendChild(op);
+    }
+    select.onchange = () => o.onControl(control.id, select.value);
+    wrap.appendChild(select);
+    refreshers.push((view) => {
+      const value = view.controls.find((c) => c.id === control.id)?.value;
+      if (typeof value === "string") select.value = value;
+    });
+    return wrap;
+  };
+  const actionControl = (control) => {
+    const b = mk("button", "tr-btn", control.name);
+    b.type = "button";
+    b.disabled = control.disabled;
+    b.onclick = () => o.onAction(control.id);
+    return b;
+  };
+  const controlElement = (control) => {
+    const el = control.kind === "number" ? numberControl(control) : control.kind === "boolean" ? booleanControl(control) : control.kind === "choice" ? choiceControl(control) : actionControl(control);
+    if (control.hint) el.title = control.hint;
+    return el;
+  };
+  const layerList = (layers) => {
+    const wrap = mk("div", "tr-layers");
+    wrap.appendChild(mk("div", "sub", t("ui.layers")));
+    for (const layer of layers) {
+      const label = mk("label", "tr-ctl");
+      const box2 = mk("input");
+      box2.type = "checkbox";
+      box2.onchange = () => o.onLayer(layer.id, box2.checked);
+      label.append(box2, document.createTextNode(` ${layer.name}`));
+      wrap.appendChild(label);
+      refreshers.push((view) => {
+        box2.checked = view.layers.find((l) => l.id === layer.id)?.on === true;
+      });
+    }
+    return wrap;
+  };
+  const rebuild = (view) => {
+    body.textContent = "";
+    refreshers.length = 0;
+    body.appendChild(mk("div", "sub", view.title));
+    const list = mk("div", "tr-ctls");
+    for (const control of view.controls) if (!control.hidden) list.appendChild(controlElement(control));
+    body.appendChild(list);
+    if (view.layers.length) body.appendChild(layerList(view.layers));
+  };
+  const renderMetrics = (rows) => {
+    metricList.textContent = "";
+    metricNodes.clear();
+    metricTitle.style.display = rows.length ? "" : "none";
+    for (const row of rows) {
+      const dd = mk("dd");
+      const text = mk("span", void 0, row.text);
+      dd.appendChild(text);
+      let bar = null;
+      if (row.ratio !== void 0) {
+        bar = mk("div", "tr-bar");
+        bar.appendChild(mk("i"));
+        dd.appendChild(bar);
+      }
+      metricList.append(mk("dt", void 0, row.name), dd);
+      metricNodes.set(row.id, { text, bar });
+    }
+  };
+  const fillBar = (bar, ratio) => {
+    bar.className = `tr-bar${ratio > 1 ? " bad" : ratio >= 0.8 ? " warn" : ""}`;
+    const fill = bar.firstElementChild;
+    fill.style.width = `${Math.round(Math.max(0, Math.min(1, ratio)) * 100)}%`;
+  };
+  return {
+    element,
+    show(view) {
+      hasBench = view !== null;
+      syncDisplay();
+      if (!view) {
+        shape = "";
+        body.textContent = "";
+        refreshers.length = 0;
+        renderMetrics([]);
+        metricKey = "";
+        return;
+      }
+      const next = shapeOf(view);
+      if (next !== shape) {
+        shape = next;
+        rebuild(view);
+      }
+      for (const refresh of refreshers) refresh(view);
+    },
+    metrics(rows) {
+      hasRoom = rows.room.length > 0;
+      syncDisplay();
+      roomLine.textContent = rows.room.map((row) => `${row.name} ${row.text}`).join(" \xB7 ");
+      const key = rows.module.map((row) => `${row.id}:${row.ratio !== void 0}`).join("|");
+      if (key !== metricKey) {
+        metricKey = key;
+        renderMetrics(rows.module);
+      }
+      for (const row of rows.module) {
+        const node = metricNodes.get(row.id);
+        if (!node) continue;
+        node.text.textContent = row.text;
+        if (node.bar && row.ratio !== void 0) fillBar(node.bar, row.ratio);
+      }
+    },
+    get visible() {
+      if (element.style.display === "none") return false;
+      const parent = element.parentElement;
+      return !parent || getComputedStyle(parent).display !== "none";
+    }
+  };
+}
+
 // src/ui.ts
 var CSS = `
 .tr-root{position:absolute;inset:0;pointer-events:none;font:12px/1.35 system-ui,-apple-system,"Segoe UI",Roboto,sans-serif;color:#e8eaee;overflow:hidden}
@@ -2372,6 +3194,13 @@ var CSS = `
 .tr-cat{flex:0 1 auto;max-height:40%}
 .tr-anim{flex:0 0 auto;max-height:18%}
 .tr-anim .list{display:flex;flex-wrap:wrap;gap:4px}.tr-anim .sub{color:#9aa3b2;margin-bottom:4px}
+.tr-bench{flex:0 1 auto;max-height:34%}
+.tr-bench .sub{color:#9aa3b2;margin-bottom:4px}
+.tr-ctls{display:flex;flex-direction:column;gap:5px}
+.tr-ctl{display:flex;flex-wrap:wrap;align-items:center;gap:6px}.tr-ctl input[type=range]{flex:1;min-width:90px}.tr-ctl output{min-width:48px;text-align:right;color:#cfd3da}
+.tr-seg{display:inline-flex;flex-wrap:wrap;gap:2px}
+.tr-layers{margin-top:6px;display:flex;flex-direction:column;gap:2px}
+.tr-metrics{display:grid;grid-template-columns:auto 1fr;gap:2px 8px;margin:6px 0 0}.tr-metrics dt{color:#9aa3b2}.tr-metrics dd{margin:0}
 .tr-tests{flex:1 1 auto;min-height:100px}
 .tr-tests .list{display:flex;flex-direction:column;gap:3px;margin-top:6px}.tr-tests .list .tr-btn{text-align:left}
 .tr-row{display:flex;flex-wrap:wrap;gap:4px;margin-top:6px;align-items:center}
@@ -2380,7 +3209,7 @@ var CSS = `
 @media (max-width:980px){.tr-left,.tr-right{display:none}.tr-root.open .tr-left,.tr-root.open .tr-right{display:flex}.tr-toggle{display:block;pointer-events:auto}.tr-root.open .tr-toggle{right:min(310px,34vw)}.tr-left{width:min(400px,46vw)}.tr-help{display:none}}
 `;
 var fold = (text) => text.normalize("NFD").replace(/[\u0300-\u036f]/g, "").toLowerCase();
-var mk = (tag, cls, text) => {
+var mk2 = (tag, cls, text) => {
   const e = document.createElement(tag);
   if (cls) e.className = cls;
   if (text !== void 0) e.textContent = text;
@@ -2388,42 +3217,42 @@ var mk = (tag, cls, text) => {
 };
 function createUi(o) {
   const { t } = o;
-  const style = mk("style");
+  const style = mk2("style");
   style.textContent = CSS;
-  const root = mk("div", "tr-root");
+  const root = mk2("div", "tr-root");
   const pos = getComputedStyle?.(o.container)?.position;
   if (!pos || pos === "static") o.container.style.position = "relative";
   root.appendChild(style);
   o.container.appendChild(root);
-  const cross = mk("div", "tr-cross");
-  cross.appendChild(mk("i"));
-  const top = mk("div", "tr-top");
-  const toolBox = mk("div", "tr-tool");
-  const status = mk("div", "tr-status");
-  const prog = mk("div", "tr-prog");
-  const progLabel = mk("b");
-  const progBar = mk("div", "tr-bar");
-  const progFill = mk("i");
+  const cross = mk2("div", "tr-cross");
+  cross.appendChild(mk2("i"));
+  const top = mk2("div", "tr-top");
+  const toolBox = mk2("div", "tr-tool");
+  const status = mk2("div", "tr-status");
+  const prog = mk2("div", "tr-prog");
+  const progLabel = mk2("b");
+  const progBar = mk2("div", "tr-bar");
+  const progFill = mk2("i");
   progBar.appendChild(progFill);
   prog.append(progLabel, progBar);
   top.append(toolBox, status, prog);
-  const bottom = mk("div", "tr-bottom");
-  const held = mk("div", "tr-held");
-  const hotbar = mk("div", "tr-hotbar");
+  const bottom = mk2("div", "tr-bottom");
+  const held = mk2("div", "tr-held");
+  const hotbar = mk2("div", "tr-hotbar");
   bottom.append(held, hotbar);
-  const help = mk("div", "tr-help");
+  const help = mk2("div", "tr-help");
   help.textContent = t("ui.help");
-  const left = mk("div", "tr-left");
-  const insp = mk("div", "tr-panel tr-insp");
-  const logPanel = mk("div", "tr-panel tr-log");
+  const left = mk2("div", "tr-left");
+  const insp = mk2("div", "tr-panel tr-insp");
+  const logPanel = mk2("div", "tr-panel tr-log");
   left.append(insp, logPanel);
-  const logTitle = mk("h3", void 0, t("ui.log"));
-  const logBar = mk("div", "tr-logbar");
-  const logBody = mk("div", "tr-logbody");
+  const logTitle = mk2("h3", void 0, t("ui.log"));
+  const logBar = mk2("div", "tr-logbar");
+  const logBody = mk2("div", "tr-logbody");
   const filters = { action: true, event: true, check: true };
   const filterBtns = [];
   for (const ch of ["action", "event", "check"]) {
-    const b = mk("button", "tr-btn on", t(`ui.filter.${ch}`));
+    const b = mk2("button", "tr-btn on", t(`ui.filter.${ch}`));
     b.type = "button";
     b.onclick = () => {
       filters[ch] = !filters[ch];
@@ -2434,8 +3263,8 @@ function createUi(o) {
     logBar.appendChild(b);
   }
   let autoscroll = true;
-  const asLabel = mk("label");
-  const asBox = mk("input");
+  const asLabel = mk2("label");
+  const asBox = mk2("input");
   asBox.type = "checkbox";
   asBox.checked = true;
   asBox.onchange = () => {
@@ -2444,7 +3273,7 @@ function createUi(o) {
   asLabel.append(asBox, document.createTextNode(" " + t("ui.autoscroll")));
   logBar.appendChild(asLabel);
   const logBtn = (label, fn) => {
-    const b = mk("button", "tr-btn", label);
+    const b = mk2("button", "tr-btn", label);
     b.type = "button";
     b.onclick = fn;
     logBar.appendChild(b);
@@ -2452,7 +3281,7 @@ function createUi(o) {
   logBtn(t("ui.copy_json"), () => {
     const text = o.log.toJSON();
     const select = () => {
-      const ta = mk("textarea");
+      const ta = mk2("textarea");
       ta.value = text;
       ta.setAttribute("readonly", "");
       ta.style.cssText = "position:fixed;left:8px;bottom:8px;width:min(480px,80vw);height:120px;z-index:99999";
@@ -2486,12 +3315,12 @@ function createUi(o) {
   const fill = (n, e) => {
     n.className = lineClass(e);
     n.textContent = "";
-    const tm = mk("time", void 0, fmtTime(e.t));
+    const tm = mk2("time", void 0, fmtTime(e.t));
     n.append(tm, document.createTextNode(e.text));
   };
   const addNode = (e) => {
     if (!filters[e.channel]) return;
-    const n = mk("div");
+    const n = mk2("div");
     fill(n, e);
     nodes.set(e.seq, n);
     logBody.appendChild(n);
@@ -2513,17 +3342,18 @@ function createUi(o) {
       if (n) fill(n, e);
     } else addNode(e);
   });
-  const right = mk("div", "tr-right");
-  const cat = mk("div", "tr-panel tr-cat");
-  const anim = mk("div", "tr-panel tr-anim");
-  const tests = mk("div", "tr-panel tr-tests");
-  right.append(cat, anim, tests);
-  cat.appendChild(mk("h3", void 0, t("ui.catalog")));
-  const itemSearch = mk("input", "tr-search");
+  const right = mk2("div", "tr-right");
+  const cat = mk2("div", "tr-panel tr-cat");
+  const anim = mk2("div", "tr-panel tr-anim");
+  const tests = mk2("div", "tr-panel tr-tests");
+  const benchPanel = createBenchPanel({ t, num: (n, d) => num(n, d), onControl: o.onControl, onLayer: o.onLayer, onAction: o.onAction });
+  right.append(cat, anim, benchPanel.element, tests);
+  cat.appendChild(mk2("h3", void 0, t("ui.catalog")));
+  const itemSearch = mk2("input", "tr-search");
   itemSearch.type = "search";
   itemSearch.placeholder = t("ui.search_items");
-  const tabs = mk("div", "tr-tabs");
-  const items = mk("div", "tr-items");
+  const tabs = mk2("div", "tr-tabs");
+  const items = mk2("div", "tr-items");
   cat.append(itemSearch, tabs, items);
   let activeGroup = "";
   const visibleItems = () => {
@@ -2535,17 +3365,17 @@ function createUi(o) {
     items.textContent = "";
     const searching = itemSearch.value.trim() !== "";
     const found = visibleItems();
-    if (!found.length) items.appendChild(mk("div", "tr-empty", t("ui.no_results")));
+    if (!found.length) items.appendChild(mk2("div", "tr-empty", t("ui.no_results")));
     for (const { item: it, group } of found) {
-      const wrap = mk("div", "tr-item");
-      const b = mk("button", "tr-btn", it.name);
-      if (searching) b.appendChild(mk("small", void 0, group));
+      const wrap = mk2("div", "tr-item");
+      const b = mk2("button", "tr-btn", it.name);
+      if (searching) b.appendChild(mk2("small", void 0, group));
       b.type = "button";
       b.title = it.note ?? it.name;
       b.onclick = () => o.onSpawn(it.id);
       wrap.appendChild(b);
       if (it.weapon) {
-        const w = mk("button", "tr-btn", "\u2694");
+        const w = mk2("button", "tr-btn", "\u2694");
         w.type = "button";
         w.title = t("ui.equip");
         w.onclick = () => o.onEquip(it.id);
@@ -2559,7 +3389,7 @@ function createUi(o) {
     const groupNames = [...o.groups().keys()];
     if (!groupNames.includes(activeGroup)) activeGroup = groupNames[0] ?? "";
     for (const g of groupNames) {
-      const b = mk("button", g === activeGroup ? "tr-btn on" : "tr-btn", g);
+      const b = mk2("button", g === activeGroup ? "tr-btn on" : "tr-btn", g);
       b.type = "button";
       b.onclick = () => {
         activeGroup = g;
@@ -2572,9 +3402,9 @@ function createUi(o) {
   renderTabs();
   itemSearch.oninput = renderItems;
   for (const box2 of [itemSearch]) box2.addEventListener("keydown", (e) => e.stopPropagation());
-  const controls = mk("div", "tr-row");
+  const controls = mk2("div", "tr-row");
   const ctl = (label, fn) => {
-    const b = mk("button", "tr-btn", label);
+    const b = mk2("button", "tr-btn", label);
     b.type = "button";
     b.onclick = () => fn(b);
     controls.appendChild(b);
@@ -2595,29 +3425,29 @@ function createUi(o) {
     o.onFast(fast);
   });
   const tapBtn = ctl(t("ui.tap"), () => o.onTap());
-  const qSel = mk("select");
+  const qSel = mk2("select");
   for (const q of ["low", "medium", "high"]) {
-    const op = mk("option", void 0, t(`ui.quality.${q}`));
+    const op = mk2("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 = mk("label", void 0, t("ui.quality") + " ");
+  const qLabel = mk2("label", void 0, t("ui.quality") + " ");
   qLabel.appendChild(qSel);
   controls.appendChild(qLabel);
-  const count = mk("span");
+  const count = mk2("span");
   controls.appendChild(count);
   cat.appendChild(controls);
-  tests.appendChild(mk("h3", void 0, t("ui.tests")));
-  const runAll = mk("button", "tr-btn", t("ui.run_all"));
+  tests.appendChild(mk2("h3", void 0, t("ui.tests")));
+  const runAll = mk2("button", "tr-btn", t("ui.run_all"));
   runAll.type = "button";
-  const summary = mk("div", "tr-summary");
-  const testSearch = mk("input", "tr-search");
+  const summary = mk2("div", "tr-summary");
+  const testSearch = mk2("input", "tr-search");
   testSearch.type = "search";
   testSearch.placeholder = t("ui.search_tests");
   testSearch.addEventListener("keydown", (e) => e.stopPropagation());
-  const list = mk("div", "list");
+  const list = mk2("div", "list");
   tests.append(runAll, summary, testSearch, list);
   testSearch.oninput = () => {
     const term = fold(testSearch.value.trim());
@@ -2640,7 +3470,7 @@ function createUi(o) {
     list.textContent = "";
     scBtns.clear();
     for (const s of o.scenarios()) {
-      const b = mk("button", "tr-btn", s.name);
+      const b = mk2("button", "tr-btn", s.name);
       b.type = "button";
       b.onclick = async () => {
         if (busy) return;
@@ -2666,7 +3496,7 @@ function createUi(o) {
       busy = false;
     }
   };
-  const toggle = mk("button", "tr-btn tr-toggle", t("ui.panel"));
+  const toggle = mk2("button", "tr-btn tr-toggle", t("ui.panel"));
   toggle.type = "button";
   const togglePanels = () => {
     root.classList.toggle("open");
@@ -2675,15 +3505,15 @@ function createUi(o) {
   toggle.onclick = togglePanels;
   root.append(cross, top, bottom, help, left, right, toggle);
   const bar = (value, max, cls) => {
-    const b = mk("div", `tr-bar ${cls}`);
-    const i = mk("i");
+    const b = mk2("div", `tr-bar ${cls}`);
+    const i = mk2("i");
     i.style.width = `${Math.max(0, Math.min(100, value / Math.max(1e-9, max) * 100))}%`;
     b.appendChild(i);
     return b;
   };
   const row = (k, v) => {
-    const r = mk("div", "r");
-    r.append(mk("span", void 0, k), mk("span", void 0, v));
+    const r = mk2("div", "r");
+    r.append(mk2("span", void 0, k), mk2("span", void 0, v));
     return r;
   };
   const num = (n, d = 1) => {
@@ -2692,12 +3522,12 @@ function createUi(o) {
   };
   const renderInspector = (i) => {
     insp.textContent = "";
-    insp.appendChild(mk("h3", void 0, t("ui.inspector")));
+    insp.appendChild(mk2("h3", void 0, t("ui.inspector")));
     if (!i) {
-      insp.appendChild(mk("div", void 0, t("ui.aim_at_something")));
+      insp.appendChild(mk2("div", void 0, t("ui.aim_at_something")));
       return;
     }
-    insp.appendChild(mk("div", "t", `${i.object} \u203A ${i.part}`));
+    insp.appendChild(mk2("div", "t", `${i.object} \u203A ${i.part}`));
     insp.appendChild(row(t("ins.material"), i.material));
     insp.appendChild(row(t("ins.status"), i.status + (i.burning ? ` \xB7 ${t("ins.burning")}` : "")));
     insp.appendChild(row(t("ins.hp"), `${num(i.hp, 0)} / ${num(i.maxHp, 0)}`));
@@ -2716,30 +3546,30 @@ function createUi(o) {
       insp.appendChild(bar(Math.min(i.stress, 1.2), 1.2, i.stress > 1 ? "bad" : i.stress > 0.7 ? "warn" : "hp"));
     }
     if (i.joints.length) {
-      insp.appendChild(mk("div", void 0, t("ins.joints") + ":"));
+      insp.appendChild(mk2("div", void 0, t("ins.joints") + ":"));
       for (const j of i.joints) {
         const tools = j.tools.length ? j.tools.join(", ") : t("tool.none");
-        insp.appendChild(mk("div", void 0, `\u2022 ${j.kind} (${j.id})${j.open ? ` \xB7 ${t("ins.open")}` : ` \u2192 ${tools}`}`));
+        insp.appendChild(mk2("div", void 0, `\u2022 ${j.kind} (${j.id})${j.open ? ` \xB7 ${t("ins.open")}` : ` \u2192 ${tools}`}`));
       }
     }
-    if (i.note) insp.appendChild(mk("div", void 0, i.note));
+    if (i.note) insp.appendChild(mk2("div", void 0, i.note));
   };
   let lastAnim = "";
   const renderAnimations = (a) => {
     anim.textContent = "";
-    anim.appendChild(mk("h3", void 0, t("ui.animations")));
+    anim.appendChild(mk2("h3", void 0, t("ui.animations")));
     if (!a) {
-      anim.appendChild(mk("div", "sub", t("ui.animations_aim")));
+      anim.appendChild(mk2("div", "sub", t("ui.animations_aim")));
       return;
     }
-    anim.appendChild(mk("div", "sub", a.name));
+    anim.appendChild(mk2("div", "sub", a.name));
     if (a.clips.length === 0) {
-      anim.appendChild(mk("div", "sub", t("ui.animations_none")));
+      anim.appendChild(mk2("div", "sub", t("ui.animations_none")));
       return;
     }
-    const l = mk("div", "list");
+    const l = mk2("div", "list");
     for (const c of a.clips) {
-      const b = mk("button", a.playing === c.id ? "tr-btn on" : "tr-btn", `\u25B6 ${t(`anim.${c.id}`) === `anim.${c.id}` ? c.id : t(`anim.${c.id}`)} (${num(c.duration, 1)} s)`);
+      const b = mk2("button", a.playing === c.id ? "tr-btn on" : "tr-btn", `\u25B6 ${t(`anim.${c.id}`) === `anim.${c.id}` ? c.id : t(`anim.${c.id}`)} (${num(c.duration, 1)} s)`);
       b.type = "button";
       b.onclick = () => o.onPlay(a.objectId, c.id);
       l.appendChild(b);
@@ -2756,7 +3586,7 @@ function createUi(o) {
     hud(s) {
       toolBox.textContent = "";
       toolBox.append(document.createTextNode(s.toolName));
-      if (s.ammo) toolBox.append(mk("small", void 0, s.ammo));
+      if (s.ammo) toolBox.append(mk2("small", void 0, s.ammo));
       if (s.status) status.textContent = s.status;
       else if (!toastTimer) status.textContent = "";
       if (s.progress) {
@@ -2777,7 +3607,7 @@ function createUi(o) {
         ];
         if (s.held.weapon) keys.push(["H", t("hud.equip", { weapon: s.held.weapon })]);
         for (const [k, label] of keys) {
-          held.append(mk("kbd", void 0, k), document.createTextNode(` ${label}  `));
+          held.append(mk2("kbd", void 0, k), document.createTextNode(` ${label}  `));
         }
       } else held.style.display = "none";
       const key = s.slots.join("|") + s.page;
@@ -2787,9 +3617,9 @@ function createUi(o) {
         slotsEl.length = 0;
         hudPage = s.page - 1;
         s.slots.forEach((name, i) => {
-          const b = mk("button", "tr-slot");
+          const b = mk2("button", "tr-slot");
           b.type = "button";
-          b.append(mk("b", void 0, String((i + 1) % 10)), document.createTextNode(name));
+          b.append(mk2("b", void 0, String((i + 1) % 10)), document.createTextNode(name));
           b.title = name;
           b.onclick = () => o.onTool(hudPage * 10 + i);
           hotbar.appendChild(b);
@@ -2827,6 +3657,11 @@ function createUi(o) {
       renderTabs();
     },
     togglePanels,
+    bench: benchPanel.show,
+    metrics: benchPanel.metrics,
+    get benchVisible() {
+      return benchPanel.visible;
+    },
     dispose() {
       offLog();
       if (toastTimer) clearTimeout(toastTimer);
@@ -2839,6 +3674,7 @@ function createUi(o) {
 
 // src/room.ts
 var FIXED_DT = 1 / 60;
+var METRICS_INTERVAL_S = 0.25;
 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]);
 function createTestRoom(options) {
@@ -2952,10 +3788,14 @@ function createTestRoom(options) {
   const tools = /* @__PURE__ */ new Map();
   let toolIndex = Math.max(0, loadout.indexOf("hand"));
   let toolId = loadout[toolIndex] ?? "hand";
+  const toolSettings = {};
+  let fuseLength;
+  const SETTING_IDS = { condition: "condition", ammoQuality: "ammo_quality", fuseLength: "fuse_length" };
   const toolState = (id) => {
     let s = tools.get(id);
     if (!s) {
-      s = arsenal.create(id, { seed: 7, reserve: 999 });
+      s = arsenal.create(id, { seed: 7, reserve: 999, ...toolSettings });
+      s.setFuseLength(fuseLength);
       s.refill();
       tools.set(id, s);
     }
@@ -3056,6 +3896,7 @@ function createTestRoom(options) {
     for (const ev of batch) {
       if (ev.type === "leak") puncture(ev);
       else if (ev.type === "ignite") igniteNear(ev.point, 0.9);
+      else if (ev.type === "explode") emitHost({ type: "explosion", source: ev.object, point: ev.point, energy: ev.energy, radius: ev.radius, cause: "part" });
       fire("event", ev);
       options.onEvent?.(ev);
     }
@@ -3076,7 +3917,7 @@ function createTestRoom(options) {
       },
       primaryUp: () => {
         useHeld = false;
-        tool.release();
+        releaseTrigger();
       },
       secondary: () => {
         if (heldEntry) throwHeld();
@@ -3233,8 +4074,7 @@ function createTestRoom(options) {
     if (heldEntry || heldPiece) releaseHeld();
     useItemPlayer = null;
     playing.length = 0;
-    projectiles.length = 0;
-    clearProjectileMeshes();
+    explosives.clear();
     fireZones.length = 0;
     burningStains.length = 0;
     for (const id of [...entries.keys()]) if (!entries.get(id)?.arena) removeEntry(id);
@@ -3470,7 +4310,6 @@ function createTestRoom(options) {
       }
     });
     player.kick(recoil[0], recoil[1]);
-    emitHost({ type: "shot", weapon: toolId, shots: shots.length, recoil });
     const f = first;
     const d = f ? num(f.distance, 1) : "";
     let text;
@@ -3618,99 +4457,46 @@ function createTestRoom(options) {
       1
     );
   };
-  const projectiles = [];
-  const projMeshes = [];
-  const clearProjectileMeshes = () => {
-    for (const m of projMeshes) m.removeFromParent();
-    projMeshes.length = 0;
-  };
-  const throwUse = (u) => {
-    const w = toolName();
-    const molotov = !!u.fire;
-    const mesh = new THREE.Mesh(
-      molotov ? new THREE.CylinderGeometry(0.035, 0.04, 0.2, 8) : new THREE.SphereGeometry(0.045, 8, 6),
-      new THREE.MeshStandardMaterial({ color: molotov ? 3897915 : 4936480, roughness: 0.6, metalness: molotov ? 0 : 0.4 })
-    );
-    mesh.castShadow = true;
-    mesh.position.set(u.origin[0], u.origin[1], u.origin[2]);
-    scene.add(mesh);
-    projMeshes.push(mesh);
-    projectiles.push({
-      mesh,
-      pos: new THREE.Vector3(u.origin[0], u.origin[1], u.origin[2]),
-      vel: new THREE.Vector3(u.velocity[0], u.velocity[1], u.velocity[2]),
-      weapon: toolId,
-      fuse: u.fuse,
-      burstOnImpact: molotov && u.fuse <= 0,
-      energy: u.energy,
-      radius: u.radius,
-      fire: u.fire,
-      age: 0
-    });
-    action("throw_projectile", t(molotov ? "act.throw.molotov" : "act.throw.grenade", { weapon: w, fuse: num(u.fuse, 1) }), { data: { weapon: toolId, fuse: u.fuse } });
-  };
-  const detonate = (p, at, impact) => {
-    const w = toolName(p.weapon);
-    const results = world.explode(at, p.energy, p.radius, "player");
-    action("explode", t("act.explode", { weapon: w, energy: num(p.energy, 0), radius: num(p.radius, 1), n: results.length }), { data: { weapon: p.weapon, energyJ: p.energy, radius: p.radius, point: at } });
-    if (p.fire) {
-      fluids.splash("fuel", [at[0], Math.max(at[1], groundAt(at[0], at[2])), at[2]], 0.5);
-      fireZones.push({ point: [at[0], Math.max(0.02, groundAt(at[0], at[2])), at[2]], radius: p.fire.radius, temperature: p.fire.temperature, remaining: p.fire.seconds, acc: 0 });
-      renderer.emit("fire", at, [0, 1, 0], 24, 3);
-      action("molotov_fire", t("act.molotov_fire", { weapon: w, seconds: num(p.fire.seconds, 0), radius: num(p.fire.radius, 1) }), { data: { weapon: p.weapon, impact } });
-    }
-  };
-  const updateProjectiles = (dt) => {
-    for (let i = projectiles.length - 1; i >= 0; i--) {
-      const p = projectiles[i];
-      p.age += dt;
-      p.vel.y -= 9.81 * dt;
-      const speed = p.vel.length();
-      const step2 = speed * dt;
-      let burst = false;
-      if (step2 > 1e-6) {
-        const d = [p.vel.x / speed, p.vel.y / speed, p.vel.z / speed];
-        const r = withoutHeld(() => world.raycast(v3(p.pos), d, step2 + 0.05));
-        if (r && r.distance <= step2 + 0.04) {
-          p.pos.set(r.point[0] - d[0] * 0.03, r.point[1] - d[1] * 0.03, r.point[2] - d[2] * 0.03);
-          if (p.burstOnImpact) burst = true;
-          else {
-            const n = r.normal;
-            const vn = p.vel.x * n[0] + p.vel.y * n[1] + p.vel.z * n[2];
-            p.vel.x = (p.vel.x - 2 * vn * n[0]) * 0.35;
-            p.vel.y = (p.vel.y - 2 * vn * n[1]) * 0.35;
-            p.vel.z = (p.vel.z - 2 * vn * n[2]) * 0.35;
-          }
-        } else p.pos.addScaledVector(p.vel, dt);
-      }
-      const g = groundAt(p.pos.x, p.pos.z) + 0.045;
-      if (p.pos.y < g) {
-        p.pos.y = g;
-        if (p.burstOnImpact) burst = true;
-        else {
-          p.vel.y = Math.abs(p.vel.y) * 0.35;
-          p.vel.x *= 0.7;
-          p.vel.z *= 0.7;
-        }
-      }
-      p.mesh.position.copy(p.pos);
-      p.mesh.rotation.x += dt * 8;
-      p.fuse -= dt;
-      if (burst || !p.burstOnImpact && p.fuse <= 0 || p.age > 30) {
-        detonate(p, v3(p.pos), burst);
-        p.mesh.removeFromParent();
-        projMeshes.splice(projMeshes.indexOf(p.mesh), 1);
-        projectiles.splice(i, 1);
-      }
-    }
-  };
+  const startFire = (weapon, at, fire2, impact) => {
+    fluids.splash("fuel", [at[0], Math.max(at[1], groundAt(at[0], at[2])), at[2]], 0.5);
+    fireZones.push({ point: [at[0], Math.max(0.02, groundAt(at[0], at[2])), at[2]], radius: fire2.radius, temperature: fire2.temperature, remaining: fire2.seconds, acc: 0 });
+    renderer.emit("fire", at, [0, 1, 0], 24, 3);
+    action("molotov_fire", t("act.molotov_fire", { weapon: toolName(weapon), seconds: num(fire2.seconds, 0), radius: num(fire2.radius, 1) }), { data: { weapon, impact } });
+  };
+  function crossingBodies() {
+    const bodies = [...entries.values()].filter((e) => !e.arena).map((e) => ({ id: e.so.objectId, box: new THREE.Box3().setFromObject(e.so.root) }));
+    const { x, y, z } = camera.position;
+    const feet = groundAt(x, z);
+    bodies.push({ id: "player", box: new THREE.Box3(new THREE.Vector3(x - PLAYER_RADIUS, feet, z - PLAYER_RADIUS), new THREE.Vector3(x + PLAYER_RADIUS, y + 0.1, z + PLAYER_RADIUS)) });
+    return bodies;
+  }
+  const explosives = createExplosives({
+    THREE,
+    scene,
+    camera,
+    world,
+    renderer,
+    arsenal,
+    objects: () => [...entries.values()].filter((e) => !e.arena).map((e) => e.so.root),
+    bodies: crossingBodies,
+    toolId: () => toolId,
+    toolName,
+    withoutHeld,
+    groundAt,
+    translate: t,
+    format: num,
+    action,
+    emitHost,
+    startFire,
+    say
+  });
   const useTool = (dt, held) => {
     aim();
     const cat = tool.def.category;
     if (cat === "hand") return;
     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") {
-      emitHost({ type: "empty", weapon: toolId });
       if (!tool.reloading && tool.reserve > 0) startReload();
       say(t(tool.reloading ? "hud.reloading" : "hud.empty"));
       return;
@@ -3718,8 +4504,13 @@ function createTestRoom(options) {
     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;
     }
+    applyUses(res, dt);
+  };
+  const applyUses = (res, dt) => {
     if (res.shots.length) fireShots(res.shots, res.recoil);
     for (const u of res.uses) {
       switch (u.kind) {
@@ -3733,7 +4524,13 @@ function createTestRoom(options) {
           heatRays(u, "heat");
           break;
         case "throw":
-          throwUse(u);
+          explosives.throwUse(u);
+          break;
+        case "place":
+          explosives.placeUse(u);
+          break;
+        case "backblast":
+          explosives.backblastUse(u);
           break;
         case "tool":
           toolWork(u, dt);
@@ -3746,6 +4543,16 @@ function createTestRoom(options) {
       }
     }
   };
+  const releaseTrigger = () => {
+    if (!tool.cooking) {
+      tool.release();
+      return;
+    }
+    aim();
+    const res = tool.release([aimO[0], aimO[1], aimO[2]], [aimD[0], aimD[1], aimD[2]]);
+    flushEvents(toolId, tool);
+    if (res) applyUses(res, 0);
+  };
   const kick = () => {
     if (!arsenal.weapons.has("kick")) return;
     aim();
@@ -3755,7 +4562,7 @@ function createTestRoom(options) {
   };
   const setTool = (id) => {
     if (!arsenal.weapons.has(id)) throw new Error(`game-test-room: unknown weapon "${id}"`);
-    tool.release();
+    releaseTrigger();
     toolId = id;
     const i = loadout.indexOf(id);
     if (i >= 0) toolIndex = i;
@@ -3763,7 +4570,8 @@ function createTestRoom(options) {
     progress = null;
     action("tool", t("act.tool", { weapon: toolName(id) }), { data: { weapon: id } });
     fire("tool", id);
-    emitHost({ type: "tool", weapon: id });
+    tool.draw();
+    flushEvents(id, tool);
   };
   const cycleTool = (dir) => {
     if (!loadout.length) return;
@@ -3995,8 +4803,16 @@ function createTestRoom(options) {
           say(t("hud.reloading"));
         }
         break;
-      case "KeyQ":
+      case "KeyQ": {
         tool.cycleMode();
+        flushEvents(toolId, tool);
+        break;
+      }
+      case "KeyX":
+        clearToolFault();
+        break;
+      case "KeyB":
+        toggleSafety();
         break;
       case "KeyZ":
         tiltKey = 1;
@@ -4014,6 +4830,9 @@ function createTestRoom(options) {
       case "KeyT":
         toggleTap();
         break;
+      case "KeyY":
+        explosives.detonateCharges();
+        break;
       case "KeyH": {
         const w = (heldEntry ?? entryOf(inspectTarget()?.object ?? ""))?.item?.weapon;
         if (w) equip(w);
@@ -4085,6 +4904,10 @@ function createTestRoom(options) {
   let timeScale = 1;
   let fastForward = false;
   let hudAcc = 1;
+  let metricsAcc = 0;
+  let ownsLoop = false;
+  const roomMetricIds = options.metrics === false ? [] : options.metrics ?? ROOM_METRICS;
+  const roomMetrics = createRoomMetrics({ gl, destruction: renderer, fluids: fluidView, ids: roomMetricIds });
   let qualityName = quality;
   const syncContainers = (sdt) => {
     for (const e of entries.values()) {
@@ -4124,7 +4947,7 @@ function createTestRoom(options) {
     const reps = fastForward ? 10 : 1;
     updateAnimations(dt);
     updateItemUse(dt);
-    updateProjectiles(dt);
+    explosives.update(dt);
     syncContainers(dt);
     for (let i = 0; i < reps; i++) {
       world.update(dt);
@@ -4135,9 +4958,10 @@ function createTestRoom(options) {
     renderer.update(dt);
     updateImpacts();
     fluidView.update(dt);
-    for (const s of tools.values()) s.update(dt);
-    if (reloadingSeen && !tool.reloading) emitHost({ type: "reload", weapon: toolId, phase: "end" });
-    reloadingSeen = tool.reloading;
+    for (const [id, s] of tools) {
+      s.update(dt);
+      flushEvents(id, s);
+    }
     for (const update2 of frameListeners) update2(dt);
     for (const tr of tracers) {
       if (tr.life > 0) {
@@ -4148,6 +4972,7 @@ function createTestRoom(options) {
     flush();
   };
   const update = (dt) => {
+    if (!ownsLoop) roomMetrics.frame(dt);
     player.update(dt);
     if (tiltKey || heldTilt > 0) {
       heldTilt = Math.max(0, Math.min(2.4, heldTilt + (tiltKey ? 2.2 : -3) * dt));
@@ -4166,6 +4991,11 @@ function createTestRoom(options) {
       hudAcc = 0;
       ui.hud(hudState());
     }
+    metricsAcc += dt;
+    if (metricsAcc >= METRICS_INTERVAL_S && ui) {
+      metricsAcc = 0;
+      if (ui.benchVisible) ui.metrics(metricRows());
+    }
   };
   const hudState = () => {
     const page = Math.floor(toolIndex / 10);
@@ -4281,15 +5111,82 @@ function createTestRoom(options) {
     log.add({ channel: "check", type: ok ? "pass" : "fail", text: `${ok ? "\u2713" : "\u2717"} ${text}`, itemId, data: { ok, ...data } });
   };
   const modules = /* @__PURE__ */ new Map();
-  const detachers = [];
+  const detachers = /* @__PURE__ */ new Map();
+  const benches = /* @__PURE__ */ new Map();
+  let activeBench = null;
+  const lastBench = () => [...benches.keys()].pop() ?? null;
+  const benchView = () => {
+    const store = activeBench ? benches.get(activeBench) : void 0;
+    if (!store) return null;
+    return { title: modules.get(store.moduleId)?.name ?? store.moduleId, controls: store.controls(), layers: store.layers() };
+  };
+  const METRIC_UNAVAILABLE = "n/a";
+  const metricText = (value, digits, unit) => typeof value === "number" ? `${num(value, digits)}${unit ? ` ${unit}` : ""}` : value ?? METRIC_UNAVAILABLE;
+  const reportedFailures = /* @__PURE__ */ new Set();
+  const reportOnce = (key, text) => {
+    if (reportedFailures.has(key)) return;
+    reportedFailures.add(key);
+    host.log(text);
+  };
+  const failureText = (error) => error instanceof Error ? error.message : String(error);
+  const moduleMetrics = () => {
+    const store = activeBench ? benches.get(activeBench) : void 0;
+    const out = {};
+    for (const metric of store?.metrics ?? []) {
+      try {
+        out[metric.id] = metric.read();
+      } catch (error) {
+        out[metric.id] = METRIC_UNAVAILABLE;
+        reportOnce(`${store?.moduleId}:metric:${metric.id}`, t("mod.metric_failed", { name: modules.get(store?.moduleId ?? "")?.name ?? "", metric: metric.id, error: failureText(error) }));
+      }
+    }
+    return out;
+  };
+  const metricRows = () => {
+    const sampled = roomMetrics.sample();
+    const room2 = roomMetricIds.flatMap((id) => {
+      const value = sampled[id];
+      return value === void 0 ? [] : [{ id, name: t(`metric.${id}`), text: num(value, id === "frame_ms" ? 1 : 0) }];
+    });
+    const values = moduleMetrics();
+    const declared = (activeBench ? benches.get(activeBench)?.metrics : void 0) ?? [];
+    const module = declared.map((metric) => {
+      const value = values[metric.id];
+      const ratio = metric.max && typeof value === "number" ? value / metric.max : void 0;
+      return { id: metric.id, name: metric.name, text: metricText(value, metric.digits ?? 0, metric.unit), ...ratio === void 0 ? {} : { ratio } };
+    });
+    return { room: room2, module };
+  };
+  const showBench = () => {
+    if (!ui) return;
+    ui.bench(benchView());
+    ui.metrics(metricRows());
+  };
   const hostListeners = /* @__PURE__ */ new Set();
   const frameListeners = /* @__PURE__ */ new Set();
-  let reloadingSeen = false;
   function emitHost(event) {
     for (const listener of hostListeners) listener(event);
   }
+  function flushEvents(id, state, recoil) {
+    const phase = state.phase;
+    for (const event of state.drain()) {
+      const hostEvent = toHostEvent(id, event, { ...recoil ? { recoil } : {}, phase });
+      if (hostEvent) emitHost(hostEvent);
+    }
+  }
   function startReload() {
-    if (tool.reload()) emitHost({ type: "reload", weapon: toolId, phase: "start" });
+    tool.reload();
+    flushEvents(toolId, tool);
+  }
+  function clearToolFault() {
+    if (!tool.clearFault()) return;
+    flushEvents(toolId, tool);
+    say(t("hud.clearing"));
+  }
+  function toggleSafety() {
+    tool.setSafety(!tool.safety);
+    flushEvents(toolId, tool);
+    say(t(tool.safety ? "hud.safety_on" : "hud.safety_off"));
   }
   const host = {
     THREE,
@@ -4297,7 +5194,31 @@ function createTestRoom(options) {
     camera,
     locale,
     groundAt,
-    tool: () => ({ weapon: toolId, category: tool.def.category, ammo: tool.ammo, capacity: tool.capacity, reserve: tool.reserve, reloading: tool.reloading }),
+    tool: () => ({
+      weapon: toolId,
+      category: tool.def.category,
+      ammo: tool.ammo,
+      capacity: tool.capacity,
+      reserve: tool.reserve,
+      reloading: tool.reloading,
+      mode: tool.mode,
+      ...tool.fault ? { fault: tool.fault } : {},
+      safety: tool.safety,
+      heat: tool.heatLevel
+    }),
+    configureTool(settings) {
+      const condition = settings[SETTING_IDS.condition];
+      const ammoQuality = settings[SETTING_IDS.ammoQuality];
+      if (condition !== void 0) toolSettings.condition = condition;
+      if (ammoQuality !== void 0) toolSettings.ammoQuality = ammoQuality;
+      const fuseMetres = settings[SETTING_IDS.fuseLength] === void 0 ? void 0 : Number(settings[SETTING_IDS.fuseLength]);
+      if (fuseMetres !== void 0 && fuseMetres > 0) fuseLength = fuseMetres;
+      for (const state of tools.values()) {
+        if (condition !== void 0) state.setCondition(condition);
+        if (ammoQuality !== void 0) state.setAmmoQuality(ammoQuality);
+        if (fuseMetres !== void 0 && fuseMetres > 0) state.setFuseLength(fuseMetres);
+      }
+    },
     on(listener) {
       hostListeners.add(listener);
       return () => hostListeners.delete(listener);
@@ -4310,6 +5231,23 @@ function createTestRoom(options) {
       action("module_note", text, { data });
     }
   };
+  const lendBench = (store) => ({
+    value: store.value,
+    layer: store.layer,
+    onChange: store.onChange,
+    patch: store.patch,
+    look: (eye, target) => room.look(eye, target)
+  });
+  const checkModuleBench = (mod, fail) => {
+    const store = createBenchStore(mod, locale, (error) => reportOnce(`${mod.id}:listener`, t("mod.listener_failed", { name: mod.name, error: failureText(error) })));
+    const { controls, layers, metrics } = store.declared;
+    if (controls.length + layers.length + metrics.length === 0) return null;
+    const r = checkBench(store.declared);
+    const text = r.ok ? t("mod.bench_ok", { name: mod.name, controls: controls.length, layers: layers.length, metrics: metrics.length }) : t("mod.bench_fail", { name: mod.name, problems: r.problems.join("; ") });
+    moduleCheck(r.ok, text, { module: mod.id, check: "bench", problems: r.problems });
+    for (const p of r.problems) fail(`bench: ${p}`);
+    return r.ok ? store : null;
+  };
   const loadModule = (mod) => {
     const report = { module: mod.id, items: [], scenarios: [], ok: true, problems: [] };
     const fail = (problem) => {
@@ -4374,8 +5312,29 @@ function createTestRoom(options) {
       report.scenarios.push(sc.id);
     }
     action("module", t("act.module_loaded", { name: mod.name, items: report.items.length, scenarios: report.scenarios.length, result: t(report.ok ? "mod.all_ok" : "mod.some_failed") }), { data: { module: mod.id, items: report.items, scenarios: report.scenarios, ok: report.ok } });
+    const bench = checkModuleBench(mod, fail);
+    detachers.get(mod.id)?.();
+    detachers.delete(mod.id);
+    const previous = benches.get(mod.id);
+    const kept = previous?.encode();
+    previous?.dispose();
+    benches.delete(mod.id);
+    for (const key of [...reportedFailures]) if (key.startsWith(`${mod.id}:`)) reportedFailures.delete(key);
     modules.set(mod.id, mod);
-    if (mod.attach) detachers.push(mod.attach(host));
+    if (bench) {
+      const seed = options.bench?.state?.[mod.id];
+      const restored = kept ?? (typeof seed === "string" ? seed : void 0);
+      if (restored !== void 0) bench.restore(restored);
+      benches.set(mod.id, bench);
+      bench.watch(() => {
+        options.bench?.onChange?.(mod.id, bench.encode());
+        if (activeBench === mod.id) ui?.bench(benchView());
+      });
+      if (!activeBench || !benches.has(activeBench)) activeBench = mod.id;
+    } else if (activeBench === mod.id) activeBench = lastBench();
+    if (mod.attach) detachers.set(mod.id, mod.attach(bench ? { ...host, bench: lendBench(bench) } : host));
+    bench?.sendInitial();
+    showBench();
     ui?.refresh();
     return report;
   };
@@ -4454,6 +5413,8 @@ function createTestRoom(options) {
     const mod = [...modules.values()].find((m) => m.id === area || m.group === area);
     const label = mod?.group ?? S.groups[area] ?? area;
     ui?.showGroup(label);
+    activeBench = mod && benches.has(mod.id) ? mod.id : lastBench();
+    showBench();
     const layout = mod?.area?.(locale);
     if (layout) return layArea(layout);
     const items = catalog.filter((item) => item.group === label);
@@ -4495,7 +5456,7 @@ function createTestRoom(options) {
         stepSim(FIXED_DT);
         t0 += FIXED_DT;
       }
-      tool.release();
+      releaseTrigger();
     },
     grab,
     throwHeld,
@@ -4512,6 +5473,15 @@ function createTestRoom(options) {
       return [...entries.values()].filter((e) => !e.arena).map((e) => e.so);
     },
     update,
+    waitUntilReady(maxSeconds = 5) {
+      let waited = 0;
+      while (tool.phase && waited < maxSeconds) {
+        update(FIXED_DT);
+        waited += FIXED_DT;
+      }
+      update(FIXED_DT);
+      return waited + FIXED_DT;
+    },
     on(type, fn) {
       listeners[type].add(fn);
       return () => listeners[type].delete(fn);
@@ -4545,8 +5515,18 @@ function createTestRoom(options) {
     loadModule,
     animations: animationsOf,
     playAnimation,
+    bench(moduleId) {
+      const id = moduleId ?? activeBench;
+      return (id ? benches.get(id) : void 0) ?? null;
+    },
+    metrics() {
+      return { room: roomMetrics.sample(), module: moduleMetrics() };
+    },
     dispose() {
-      for (const detach of detachers.splice(0)) detach();
+      for (const detach of detachers.values()) detach();
+      detachers.clear();
+      for (const store of benches.values()) store.dispose();
+      benches.clear();
       cancelAnimationFrame?.(raf);
       window.removeEventListener("resize", onResize);
       player.dispose();
@@ -4554,7 +5534,7 @@ function createTestRoom(options) {
       renderer.dispose();
       fluidView.dispose();
       for (const tr of tracers) tr.line.removeFromParent();
-      clearProjectileMeshes();
+      explosives.clear();
       if (ownRenderer) {
         gl.dispose();
         dom.remove();
@@ -4617,19 +5597,33 @@ function createTestRoom(options) {
       onPlay: (objectId, clipId) => {
         playAnimation(clipId, objectId);
       },
-      onResize: resize
+      onResize: resize,
+      onControl: (id, value) => {
+        if (activeBench) benches.get(activeBench)?.set(id, value);
+      },
+      onLayer: (id, on) => {
+        if (activeBench) benches.get(activeBench)?.setLayer(id, on);
+      },
+      onAction: (id) => {
+        if (activeBench) benches.get(activeBench)?.act(id);
+      }
     });
     ui.hud(hudState());
+    showBench();
   }
   let raf = 0;
   if (ownRenderer && typeof requestAnimationFrame === "function") {
     let last = performance.now();
+    ownsLoop = true;
     const loop = (now) => {
       raf = requestAnimationFrame(loop);
-      const dt = Math.min(0.05, (now - last) / 1e3);
+      const realDelta = (now - last) / 1e3;
+      roomMetrics.frame(realDelta);
+      const dt = Math.min(0.05, realDelta);
       last = now;
       if (!scenarioRunning) update(dt);
       gl.render(scene, camera);
+      roomMetrics.rendered();
     };
     raf = requestAnimationFrame(loop);
   }
@@ -4651,7 +5645,9 @@ export {
   buildFromSpec,
   createLog,
   createTestRoom,
+  decodeBenchState,
   demoItems,
+  encodeBenchState,
   locales,
   makeScenarios,
   resolveStrings,