@adatechnology/game-test-room 0.11.1 → 0.13.0

package/dist/index.js

@@ -1,5 +1,5 @@
 // src/room.ts
-import { createDestruction, JOINT_DEFAULTS as JOINT_DEFAULTS2, resolveStrings as resolveDestructionStrings } from "@adatechnology/game-destruction";
+import { createDestruction, JOINT_DEFAULTS, resolveStrings as resolveDestructionStrings } from "@adatechnology/game-destruction";
 import { createAudioEngine, createAudioSink } from "@adatechnology/game-audio";
 import { createDestructionRenderer, createDestructionSound, specFromObject3D } from "@adatechnology/game-destruction-three";
 import { createArsenal, DEFAULT_LOADOUT } from "@adatechnology/game-weapons";
@@ -7,1256 +7,283 @@ import { createFilmLcg, createFluids, createItemUse, ITEM_USES, resolveStrings a
 import { createFilmBridge, createFilmManager, createFluidRenderer } from "@adatechnology/game-fluids-three";
 import { createGroundField, createVfx } from "@adatechnology/game-vfx";
 import { createGroundPatch, createVfxRenderer } from "@adatechnology/game-vfx-three";
-import { checkAnimation, checkBench, checkDestructible, checkSpec, createEnvironmentBus } from "@adatechnology/game-contracts";
+import { checkAnimation, checkBench, checkDestructible, checkSpec, createEnvironmentBus, shotExtras, useToHit } from "@adatechnology/game-contracts";
 
 // src/items.ts
-import { buildFrame } from "@adatechnology/game-destruction";
+var box = (id, material, size, position, extra = {}) => ({ id, material, shape: { kind: "box", size }, position, ...extra });
+var joint = (a, b, kind, extra = {}) => ({ a, b, kind, ...extra });
+function brickWallSpec(cols = 8, rows = 6, panel = [1.25, 0.5, 0.2]) {
+  const parts = [];
+  const joints = [];
+  const id = (c, r) => `brick_${r}_${c}`;
+  for (let r = 0; r < rows; r++) {
+    for (let c = 0; c < cols; c++) {
+      parts.push(box(id(c, r), "brick", panel, [(c - (cols - 1) / 2) * panel[0], panel[1] / 2 + r * panel[1], 0], { anchored: r === 0 }));
+      if (c > 0) joints.push(joint(id(c - 1, r), id(c, r), "mortar"));
+      if (r > 0) joints.push(joint(id(c, r - 1), id(c, r), "mortar"));
+    }
+  }
+  return { name: "brick wall", parts, joints, tags: ["structure"] };
+}
 
-// src/build-from-spec.ts
-var MATERIAL_COLORS = {
-  steel: 9278620,
-  cast_iron: 4869458,
-  aluminium: 12896718,
-  copper: 12088122,
-  wood_soft: 12158287,
-  wood_hard: 8014374,
-  plywood: 13214826,
-  mdf: 11045732,
-  glass: 10278630,
-  tempered_glass: 10278630,
-  ceramic: 15328474,
-  concrete: 10132118,
-  brick: 10831662,
-  plaster: 15131092,
-  stone: 7828591,
-  plastic: 3897540,
-  rubber: 2039586,
-  fabric: 9063262,
-  foam: 14926936,
-  leather: 5978662,
-  paper: 15657695,
-  foliage: 4165434,
-  green_wood: 7031339,
-  cactus: 4095306,
-  flesh_fruit: 13781810,
-  wax: 15721141,
-  soil: 4862754
+// src/arena.ts
+var sizeOf = (shape) => shape.kind === "box" ? shape.size : shape.kind === "cylinder" ? [shape.radius * 2, shape.height, shape.radius * 2] : [shape.radius * 2, shape.radius * 2, shape.radius * 2];
+function specBounds(THREE, spec, position, rotationY, options = {}) {
+  const out = { minX: Infinity, maxX: -Infinity, minY: Infinity, maxY: -Infinity, minZ: Infinity, maxZ: -Infinity };
+  const q = new THREE.Quaternion().setFromEuler(new THREE.Euler(0, rotationY, 0));
+  const v = new THREE.Vector3();
+  const e = new THREE.Euler();
+  const pq = new THREE.Quaternion();
+  let any = false;
+  for (const p of spec.parts) {
+    if (options.onlyPart !== void 0 && p.id !== options.onlyPart) continue;
+    const [sx, sy, sz] = sizeOf(p.shape);
+    pq.setFromEuler(e.set(p.rotation?.[0] ?? 0, p.rotation?.[1] ?? 0, p.rotation?.[2] ?? 0, "XYZ"));
+    const corners = [];
+    let top = -Infinity;
+    for (const cx of [-0.5, 0.5]) for (const cy of [-0.5, 0.5]) for (const cz of [-0.5, 0.5]) {
+      v.set(cx * sx, cy * sy, cz * sz).applyQuaternion(pq);
+      const c = [v.x + p.position[0], v.y + p.position[1], v.z + p.position[2]];
+      top = Math.max(top, c[1]);
+      corners.push(c);
+    }
+    if (top < (options.minHeight ?? 0)) continue;
+    any = true;
+    for (const c of corners) {
+      v.set(c[0], c[1], c[2]).applyQuaternion(q);
+      out.minX = Math.min(out.minX, v.x + position[0]);
+      out.maxX = Math.max(out.maxX, v.x + position[0]);
+      out.minY = Math.min(out.minY, v.y + position[1]);
+      out.maxY = Math.max(out.maxY, v.y + position[1]);
+      out.minZ = Math.min(out.minZ, v.z + position[2]);
+      out.maxZ = Math.max(out.maxZ, v.z + position[2]);
+    }
+  }
+  return any ? out : null;
+}
+var tableSpec = () => {
+  const parts = [{ id: "top", material: "wood_hard", shape: { kind: "box", size: [1.6, 0.05, 0.8] }, position: [0, 0.755, 0] }];
+  const joints = [];
+  for (const [i, [x, z]] of [
+    [-0.72, -0.32],
+    [0.72, -0.32],
+    [-0.72, 0.32],
+    [0.72, 0.32]
+  ].entries()) {
+    parts.push({ id: `leg_${i + 1}`, material: "wood_hard", shape: { kind: "box", size: [0.06, 0.73, 0.06] }, position: [x, 0.365, z], anchored: true });
+    joints.push({ a: `leg_${i + 1}`, b: "top", kind: "screw" });
+  }
+  return { name: "table", parts, joints, tags: ["furniture"] };
 };
-var TRANSPARENT = { glass: 0.38, tempered_glass: 0.38 };
-function buildFromSpec(THREE, spec, options = {}) {
-  const root = new THREE.Group();
-  root.name = spec.name ?? "object";
-  const seg = options.segments ?? 12;
-  const shadows = options.shadows !== false;
-  const mats = /* @__PURE__ */ new Map();
-  const materialFor = (p) => {
-    const color = options.colors?.[p.id] ?? options.colors?.[p.material] ?? MATERIAL_COLORS[p.material] ?? 8947848;
-    const key = `${p.material}:${color}`;
-    let m = mats.get(key);
-    if (!m) {
-      const alpha = TRANSPARENT[p.material];
-      const metal = p.material === "steel" || p.material === "aluminium" || p.material === "copper" || p.material === "cast_iron";
-      m = new THREE.MeshStandardMaterial({
-        color,
-        roughness: alpha ? 0.1 : metal ? 0.45 : 0.85,
-        metalness: metal ? 0.7 : 0,
-        transparent: !!alpha,
-        opacity: alpha ?? 1,
-        depthWrite: !alpha
+var shelfSpec = () => {
+  const parts = [];
+  const joints = [];
+  for (const [i, x] of [-0.6, 0.6].entries()) {
+    parts.push({ id: `upright_${i + 1}`, material: "wood_hard", shape: { kind: "box", size: [0.04, 1.7, 0.4] }, position: [x, 0.85, 0], anchored: true });
+  }
+  for (const [i, y] of [0.4, 0.9, 1.4].entries()) {
+    parts.push({ id: `board_${i + 1}`, material: "wood_soft", shape: { kind: "box", size: [1.2, 0.03, 0.4] }, position: [0, y, 0] });
+    joints.push({ a: `board_${i + 1}`, b: "upright_1", kind: "screw" }, { a: `board_${i + 1}`, b: "upright_2", kind: "screw" });
+  }
+  return { name: "shelf", parts, joints, tags: ["furniture"] };
+};
+var defaultScenery = (wallZ) => ({
+  target_wall: { spec: brickWallSpec(), position: [0, 0, wallZ], colors: { brick: 10831662 } },
+  table: { spec: tableSpec(), position: [3.5, 0, 0], top: { part: "top", y: 0.78 } },
+  shelf: { spec: shelfSpec(), position: [-3.5, 0, 0], colors: { wood_soft: 13081186 } }
+});
+var DEFAULT_WALL_Z = -11;
+var WALL_ID = "target_wall";
+var TABLE_ID = "table";
+function resolveScenery(scenery) {
+  const merged = new Map(Object.entries(defaultScenery(DEFAULT_WALL_Z)));
+  for (const [id, obj] of Object.entries(scenery ?? {})) {
+    if (obj === null) {
+      merged.delete(id);
+      continue;
+    }
+    const old = merged.get(id);
+    const position = obj.position ?? old?.position;
+    if (!position) throw new Error(`game-test-room: scenery "${id}" is new, so it needs a position`);
+    merged.set(id, { ...obj, position });
+  }
+  return [...merged.entries()].map(([id, o]) => ({ id, spec: o.spec, position: o.position, rotationY: o.rotationY ?? 0, colors: o.colors, build: o.build, label: o.label, top: o.top, spout: o.spout }));
+}
+function createArena(THREE, size, scene, scenery, tapOption) {
+  const group = new THREE.Group();
+  group.name = "test-room-arena";
+  scene.background = new THREE.Color(10466504);
+  group.add(new THREE.HemisphereLight(13624319, 7037527, 0.75));
+  const sun = new THREE.DirectionalLight(16777215, 2.1);
+  sun.position.set(7, 13, 8);
+  sun.castShadow = true;
+  sun.shadow.mapSize.set(1024, 1024);
+  const sc = sun.shadow.camera;
+  sc.left = -16;
+  sc.right = 16;
+  sc.top = 16;
+  sc.bottom = -16;
+  sc.near = 1;
+  sc.far = 40;
+  sun.shadow.bias = -6e-4;
+  group.add(sun);
+  const floor = new THREE.Mesh(new THREE.PlaneGeometry(size * 2, size * 2), new THREE.MeshStandardMaterial({ color: 9342602, roughness: 0.95 }));
+  floor.rotation.x = -Math.PI / 2;
+  floor.receiveShadow = true;
+  floor.name = "floor";
+  group.add(floor);
+  const grid = new THREE.GridHelper(size * 2, size * 2, 5000274, 7829371);
+  grid.position.y = 4e-3;
+  group.add(grid);
+  const sceneryObjects = resolveScenery(scenery);
+  const wallObject = sceneryObjects.find((o) => o.id === WALL_ID);
+  const wallZ = wallObject ? wallObject.position[2] : DEFAULT_WALL_Z;
+  const playerStart = [0, 1.7, 5];
+  const pts = [];
+  const rx = -1.6;
+  for (let z = Math.round(playerStart[2]); z >= wallZ; z--) {
+    const d = playerStart[2] - z;
+    const len = d % 5 === 0 ? 0.5 : 0.2;
+    pts.push(rx, 0.01, z, rx + len, 0.01, z);
+  }
+  pts.push(rx, 0.01, playerStart[2], rx, 0.01, wallZ);
+  const rg = new THREE.BufferGeometry();
+  rg.setAttribute("position", new THREE.Float32BufferAttribute(pts, 3));
+  group.add(new THREE.LineSegments(rg, new THREE.LineBasicMaterial({ color: 16765503 })));
+  for (let d = 5; playerStart[2] - d >= wallZ; d += 5) {
+    try {
+      const canvas = document.createElement("canvas");
+      canvas.width = 128;
+      canvas.height = 64;
+      const ctx = canvas.getContext("2d");
+      if (!ctx) break;
+      ctx.fillStyle = "#ffd23f";
+      ctx.font = "bold 44px sans-serif";
+      ctx.textAlign = "center";
+      ctx.fillText(`${d} m`, 64, 48);
+      const sprite = new THREE.Sprite(new THREE.SpriteMaterial({ map: new THREE.CanvasTexture(canvas), transparent: true, depthWrite: false }));
+      sprite.scale.set(1.2, 0.6, 1);
+      sprite.position.set(rx - 0.8, 0.45, playerStart[2] - d);
+      group.add(sprite);
+    } catch {
+      break;
+    }
+  }
+  const tops = [];
+  const surfaces = [{ id: "floor", point: [0, 0, 0], normal: [0, 1, 0], halfSize: [size, size], porosity: 0.05 }];
+  for (const o of sceneryObjects) {
+    if (!o.top) continue;
+    const b = specBounds(THREE, o.spec, o.position, o.rotationY, { onlyPart: o.top.part });
+    if (!b) continue;
+    const top = o.position[1] + o.top.y;
+    tops.push({ id: o.id, topPart: o.top.part, minX: b.minX, maxX: b.maxX, minZ: b.minZ, maxZ: b.maxZ, top });
+    surfaces.push({ id: o.id, point: [(b.minX + b.maxX) / 2, top, (b.minZ + b.maxZ) / 2], normal: [0, 1, 0], halfSize: [(b.maxX - b.minX) / 2, (b.maxZ - b.minZ) / 2], porosity: 0.3 });
+  }
+  const colliders = [];
+  for (const o of sceneryObjects) {
+    const b = specBounds(THREE, o.spec, o.position, o.rotationY, { minHeight: 0.1 });
+    if (!b) continue;
+    colliders.push(o.id === WALL_ID ? [-size, b.minZ - 1, size, b.maxZ + 0.1] : [b.minX, b.minZ, b.maxX, b.maxZ]);
+  }
+  let tapSpout = null;
+  const tableTop = tops.find((t) => t.id === TABLE_ID);
+  const spouting = sceneryObjects.find((o) => o.spout);
+  if (spouting?.spout && tapOption !== null) {
+    const s = new THREE.Vector3(spouting.spout[0], spouting.spout[1], spouting.spout[2]).applyAxisAngle(new THREE.Vector3(0, 1, 0), spouting.rotationY);
+    tapSpout = [spouting.position[0] + s.x, spouting.position[1] + s.y, spouting.position[2] + s.z];
+  } else if (tableTop && tapOption !== null) {
+    const cx = (tableTop.minX + tableTop.maxX) / 2;
+    const cz = (tableTop.minZ + tableTop.maxZ) / 2;
+    const y = tableTop.top;
+    if (tapOption) {
+      const rot = tapOption.rotationY ?? 0;
+      const sp = new THREE.Vector3(tapOption.spout[0], tapOption.spout[1], tapOption.spout[2]).applyAxisAngle(new THREE.Vector3(0, 1, 0), rot);
+      const at = tapOption.position ?? [cx + 0.3 - sp.x, y, cz - sp.z];
+      const model = tapOption.build(THREE);
+      model.position.set(at[0], at[1], at[2]);
+      model.rotation.y = rot;
+      model.traverse((m) => {
+        m.castShadow = true;
       });
-      mats.set(key, m);
+      group.add(model);
+      tapSpout = [at[0] + sp.x, at[1] + sp.y, at[2] + sp.z];
+    } else {
+      const postX = tableTop.maxX + 0.35;
+      const tapMat = new THREE.MeshStandardMaterial({ color: 12172996, metalness: 0.8, roughness: 0.35 });
+      const post = new THREE.Mesh(new THREE.CylinderGeometry(0.04, 0.04, 1.4, 10), tapMat);
+      post.position.set(postX, 0.7, cz);
+      const arm = new THREE.Mesh(new THREE.CylinderGeometry(0.025, 0.025, postX - (cx + 0.3), 10), tapMat);
+      arm.rotation.z = Math.PI / 2;
+      arm.position.set((postX + cx + 0.3) / 2, y + 0.6, cz);
+      const spoutMesh = new THREE.Mesh(new THREE.CylinderGeometry(0.025, 0.025, 0.1, 10), tapMat);
+      spoutMesh.position.set(cx + 0.3, y + 0.55, cz);
+      for (const m of [post, arm, spoutMesh]) {
+        m.castShadow = true;
+        group.add(m);
+      }
+      tapSpout = [cx + 0.3, y + 0.5, cz];
+      colliders.push([postX - 0.05, cz - 0.1, postX + 0.05, cz + 0.1]);
     }
-    return m;
-  };
-  for (const p of spec.parts) {
-    let geo;
-    const s = p.shape;
-    if (s.kind === "box") geo = new THREE.BoxGeometry(s.size[0], s.size[1], s.size[2]);
-    else if (s.kind === "cylinder") geo = new THREE.CylinderGeometry(s.radius, s.radius, s.height, seg);
-    else geo = new THREE.SphereGeometry(s.radius, seg, Math.max(6, seg - 4));
-    const mesh = new THREE.Mesh(geo, materialFor(p));
-    mesh.name = p.id;
-    mesh.userData.destructionPart = p.id;
-    mesh.userData.destructionMaterial = p.material;
-    mesh.position.set(p.position[0], p.position[1], p.position[2]);
-    if (p.rotation) mesh.rotation.set(p.rotation[0], p.rotation[1], p.rotation[2], "XYZ");
-    mesh.castShadow = shadows && !TRANSPARENT[p.material];
-    mesh.receiveShadow = shadows;
-    root.add(mesh);
   }
-  return root;
+  return {
+    group,
+    objects: sceneryObjects,
+    surfaces,
+    colliders,
+    playerStart,
+    wallZ,
+    tops,
+    tapSpout,
+    sun
+  };
 }
 
-// src/locale.ts
-var en = {
-  items: {
-    chair: "Wooden chair",
-    sofa: "Sofa",
-    shelf: "Shelf with boards",
-    old_tv: "Old TV",
-    steel_sheet: "Steel sheet on a stand",
-    glass_pane: "Glass pane",
-    concrete_block: "Concrete block",
-    brick_column: "Brick column",
-    building_frame: "Building frame",
-    car_door: "Car door",
-    small_tree: "Small tree",
-    potted_plant: "Potted plant",
-    coffee_cup: "Cup of coffee",
-    glass_bottle: "Glass bottle",
-    wooden_crate: "Wooden crate",
-    steel_drum: "Steel drum",
-    plastic_bucket: "Plastic bucket",
-    jerrycan: "Jerrycan",
-    gas_bottle: "Gas bottle"
-  },
-  groups: { furniture: "Furniture", structure: "Structure", vehicles: "Vehicles", plants: "Plants", items: "Items", containers: "Containers" },
-  text: {
-    "locale.decimal": ".",
-    yes: "yes",
-    no: "no",
-    piece: "piece",
-    coords: "x {x} \xB7 z {z}",
-    "count.piece.one": "1 piece",
-    "count.piece.other": "{n} pieces",
-    "count.joint.one": "1 joint",
-    "count.joint.other": "{n} joints",
-    "count.dent.one": "1 dent",
-    "count.dent.other": "{n} dents",
-    "count.hole.one": "1 hole",
-    "count.hole.other": "{n} holes",
-    "count.crack.one": "1 crack",
-    "count.crack.other": "{n} cracks",
-    "joint.generic": "joint",
-    "lost.broken": "broke",
-    "lost.melted": "melted away",
-    "lost.ashes": "burned to ash",
-    "tool.none": "by hand only",
-    "arena.target_wall": "Target wall",
-    "arena.table": "Table",
-    "arena.shelf": "Shelf",
-    "surface.floor": "on the floor",
-    "surface.ground": "on the floor",
-    "surface.table": "on the table",
-    "by.break": "broken loose",
-    "by.tool": "undone with a tool",
-    "by.part_lost": "the part next to it was lost",
-    "dmg.ballistic": "ballistic",
-    "dmg.blunt": "blunt",
-    "dmg.slash": "slash",
-    "dmg.explosive": "blast",
-    "dmg.fire": "fire",
-    "dmg.heat": "heat",
-    "effect.caffeine": "caffeine",
-    "effect.alcohol": "alcohol",
-    "effect.poison": "poison",
-    "effect.disgust": "disgust",
-    "ev.dent": "{where}: dent of {mm} mm, {hp}",
-    "ev.hole.through": "{where}: {mm} mm hole went through, {hp}",
-    "ev.hole.stuck": "{where}: {mm} mm hole, did not go through, {hp}",
-    "ev.dents": "{where}: {n} dents, deepest {mm} mm, {hp}",
-    "ev.holes": "{where}: {n} holes of {mm} mm, {thr} went through, {hp}",
-    "ev.leak.tail": ", leaking {liquid} at {rate} l/s",
-    "ev.leak.alone": "{where}: leaking {liquid} at {rate} l/s",
-    "ev.crack": "{where}: cracked, {rays} rays up to {cm} cm, {hp}",
-    "ev.ricochet": "{where}: bullet ricocheted, {energy} J left",
-    "ev.fracture.shatter": "{where}: shattered into {n} shards",
-    "ev.fracture.crumble": "{where}: crumbled into {n} chunks",
-    "ev.fracture.splinter": "{where}: splintered into {n} pieces",
-    "ev.fracture.tear": "{where}: torn into {n} scraps",
-    "ev.fracture.snap": "{where}: snapped into {n} pieces",
-    "ev.fracture.none": "{where}: broke into {n} pieces",
-    "ev.detach": "{obj}: {a} came off {b} ({by}); the object now has {pieces}",
-    "ev.detach.many.break": "{obj}: {joints} broke loose; the object now has {pieces}",
-    "ev.detach.many.tool": "{obj}: {joints} undone with a tool; the object now has {pieces}",
-    "ev.lost.tail": " and came loose from {joints}; the object now has {pieces}",
-    "ev.lost.alone": "{where}: {verb} and came loose from {joints}; the object now has {pieces}",
-    "ev.cracks": "{where}: cracking under the load, {n} cracks so far, longest {cm} cm, {hp}",
-    "ev.disassemble": "{obj}: undoing the {kind} between {a} and {b} with {tool}: {pct}%",
-    "ev.ignite": "{where}: caught fire at {temp} \xB0C",
-    "ev.ignite.many": "{obj}: {n} parts caught fire at {temp} \xB0C ({parts})",
-    "ev.extinguish": "{where}: fire put out",
-    "ev.extinguish.many": "{obj}: fire put out on {n} parts ({parts})",
-    "ev.burnout": "{where}: burned to ash",
-    "ev.melt": "{where}: melting, {pct}% melted away",
-    "ev.drip": "{where}: dripping molten material",
-    "ev.explode": "{where}: exploded, {energy} J within {radius} m",
-    "ev.destroyed": "{obj}: destroyed",
-    "ev.damage": "{where}: {type} damage {amount}, {hp}",
-    "ev.damage.overload": "{where}: crushed by the weight it carries, lost {amount} hp so far, {hp}",
-    "ev.stress": "{where}: overloaded at {stress}% of its capacity, carrying {load} kg",
-    "ev.collapse": "{obj}: collapsed, {pieces} fell ({mass} kg): {parts}",
-    "ev.stain_ignite": "The {liquid} stain at x {x} \xB7 z {z} caught fire and will burn for about {seconds} s",
-    "ev.stain_burned": "The burning stain burned itself out",
-    "ev.fire_dries": "Fire dried the wet stains nearby",
-    "fl.fill": "{who}: filled with {liquid} (+{liters} l)",
-    "fl.pour": "{who}: pouring {liquid} at {rate} l/s",
-    "fl.spill": "{who}: spilled {liquid} over the lip at {rate} l/s",
-    "fl.leak": "{who}: leaking {liquid} at {rate} l/s",
-    "fl.drink": "{who}: drank {liters} l, thirst +{thirst}",
-    "fl.burn": "too hot: burned the mouth",
-    "fl.empty": "{who}: empty",
-    "fl.splash": "Splash of {liquid}",
-    "fl.stain": "Stain of {liquid} {surface} at {where}",
-    "fl.stains": "{n} stains of {liquid} {surface}, the latest at {where}",
-    "fl.dried": "A stain dried up",
-    "fl.dried.mark": "A stain dried and left a mark",
-    "fl.dried.known": "The {liquid} stain {surface} at {where} dried up",
-    "fl.dried.known.mark": "The {liquid} stain {surface} at {where} dried and left a mark",
-    "fl.dried.many": "{n} {liquid} stains dried up",
-    "fl.dried.many.mark": "{n} {liquid} stains dried and left marks",
-    "fl.mix": "{who}: {from} mixed into {into}",
-    "act.anim_start": '{name}: animation "{clip}" ({seconds} s)',
-    "act.anim_event": '{name}: "{clip}" event {type}',
-    "act.anim_end": '{name}: animation "{clip}" finished',
-    "act.module_loaded": 'Module "{name}" loaded: {items} item(s), {scenarios} scenario(s), contract checks: {result}',
-    "mod.all_ok": "all passed",
-    "mod.some_failed": "some FAILED",
-    "mod.destructible_ok": "{name}: destructible contract ok ({parts} parts, hit and state well-formed)",
-    "mod.destructible_fail": "{name}: destructible contract broken: {problems}",
-    "mod.animation_ok": '{name}: animation "{clip}" ok ({seconds} s)',
-    "mod.spec_ok": "{name}: spec ok ({parts} parts)",
-    "mod.spec_fail": "{name}: spec broken: {problems}",
-    "mod.spec_warn": "{name}: spec warning: {warning}",
-    "mod.animation_fail": '{name}: animation "{clip}" broken: {problems}',
-    "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",
-    "act.tool": "Equipped {weapon}",
-    "act.shoot.hit": "{weapon}: shot, {energy} J, hit {where} at {dist} m",
-    "act.shoot.miss": "{weapon}: shot, {energy} J, hit nothing",
-    "act.shoot.pellets": "{weapon}: shot, {n} projectiles of up to {energy} J, {hits} hit {where} at {dist} m",
-    "act.melee.hit": "{weapon}: strike, {energy} J, hit {where} at {dist} m",
-    "act.melee.miss": "{weapon}: struck the air",
-    "act.flame.hit": "{weapon}: flame at {temp} \xB0C on {where}",
-    "act.flame.air": "{weapon}: flame, nothing in range",
-    "act.heat.hit": "{weapon}: heating {where} at {temp} \xB0C",
-    "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",
-    "act.tool.nojoint": "{weapon}: no joint near {where}",
-    "act.tool.refused": "{weapon} cannot undo the {kind} of {obj}; it needs: {need}",
-    "act.extinguish.hit": "{weapon}: foam on {what}",
-    "act.extinguish.air": "{weapon}: foam, nothing in range",
-    "act.grab": "Grabbed {name} ({kg} kg)",
-    "act.drop": "Dropped {name}",
-    "act.throw": "Threw {name} at {speed} m/s",
-    "act.landing": "{name} landed at {speed} m/s: {energy} J",
-    "act.impact": "{name} hit {where} at {speed} m/s: {energy} J of blunt damage",
-    "act.use_item": "{name}: {use}",
-    "act.tap.on": "Tap opened",
-    "act.tap.off": "Tap closed",
-    "use.drink": "drink",
-    "use.sip": "sip",
-    "use.chug": "chug",
-    "use.pour": "pour",
-    "use.pour_out": "pour out",
-    "use.open": "open",
-    "use.close": "close",
-    "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)",
-    "hud.empty_container": "{name} is empty",
-    "hud.refused": "Wrong tool for the {kind}",
-    "hud.drop": "drop",
-    "hud.rotate": "rotate",
-    "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 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",
-    "ui.filter.check": "checks",
-    "ui.autoscroll": "autoscroll",
-    "log.export_cancelled": "export cancelled",
-    "ui.copy_json": "Copy JSON",
-    "ui.download_ndjson": "Download NDJSON",
-    "ui.download_txt": "Download TXT",
-    "ui.clear_log": "Clear",
-    "ui.catalog": "Catalogue",
-    "ui.clear": "Clear",
-    "ui.reset_all": "Reset all",
-    "ui.slow": "Slow motion 0.25\xD7",
-    "ui.fast": "Time \xD710",
-    "ui.tap": "Tap",
-    "ui.blast.shelter": "Shelter",
-    "ui.blast.fragmentHits": "Fragments",
-    "ui.blast.confinement": "Confinement",
-    "ui.blast.shelter.hint": "Blasts: walls and other parts between the blast and the target take their share",
-    "ui.blast.fragmentHits.hint": "Blasts: the pieces of what breaks fly on and hit what is behind",
-    "ui.blast.confinement.hint": "Blasts: pressure builds up in an enclosed room",
-    "metric.blast_shelter": "Blast reaching (%)",
-    "metric.blast_confinement": "Blast pressure (x)",
-    "metric.blast_fragments": "Fragment hits",
-    "act.blast_report": "Blast: {shelter}% reached the most sheltered target, pressure x{confinement}, {fragments} fragment hits, {n} targets",
-    "ui.quality": "Quality",
-    "ui.quality.low": "low",
-    "ui.quality.medium": "medium",
-    "ui.quality.high": "high",
-    "ui.equip": "Equip as a tool",
-    "ui.search_items": "Search items (all groups)",
-    "ui.search_tests": "Search tests",
-    "ui.no_results": "Nothing found",
-    "ui.objects": "{n} objects",
-    "ui.tests": "Tests",
-    "ui.run_all": "Run all",
-    "ui.running": "Running...",
-    "ui.report": "{passed} passed, {failed} failed",
-    "ui.panel": "Panels",
-    "ui.inspector": "Inspector",
-    "ui.aim_at_something": "Aim at an object",
-    "ins.material": "Material",
-    "ins.status": "Status",
-    "ins.burning": "burning",
-    "ins.hp": "Hit points",
-    "ins.temperature": "Temperature",
-    "ins.char": "Charred",
-    "ins.melt": "Melted",
-    "ins.liters": "Liquid",
-    "ins.damage": "Marks",
-    "ins.damage_counts": "{dents}, {holes}, {cracks}",
-    "ins.mass": "Mass",
-    "ins.load": "Load",
-    "ins.stress": "Stress",
-    "ins.joints": "Joints",
-    "ins.open": "open",
-    "sc.start": "Scenario: {name}",
-    "sc.pass": "Scenario passed: {name}",
-    "sc.fail": "Scenario FAILED: {name}",
-    "sc.error": "the scenario threw an error: {msg}",
-    "leg.still": "leg_1 still attached",
-    "leg.gone": "leg_1 came off",
-    "sc.steel_through_hole": "9 mm into a steel sheet makes a through hole",
-    "sc.steel_through_hole.check": "9 mm into 3 mm steel: {holes} hole(s) of {mm} mm, went through: {through}, sheet {hp} hp (expected: through)",
-    "sc.concrete_stops_bullet": "9 mm into a concrete block does not go through",
-    "sc.concrete_stops_bullet.check": "9 mm into 40 cm of concrete: went through: {through}, {dents}, {holes}, {cracks}, block {hp} hp (expected: stopped, wall behind untouched)",
-    "sc.hammer_dents_drum": "Hammer dents a steel drum",
-    "sc.hammer_dents_drum.check": "Hammer on the drum: {swings} swing(s), {dents} dent(s), first {depth} mm deep, body {hp} hp (expected: dented, not broken)",
-    "sc.glass_shatters": "Glass pane shatters on the first 9 mm shot",
-    "sc.glass_shatters.check": "Glass pane: broken after {shots} shot(s) into {n} shards (expected: broken on the first shot, at least 4 shards)",
-    "sc.shotgun_splinters_crate": "Shotgun splinters a wooden crate",
-    "sc.shotgun_splinters_crate.check": "12 ga on the crate: {shots} shot(s), {splinters} board(s) splintered, {holes} holes (expected: at least one splintered)",
-    "sc.kick_chair_leg": "A kick takes a chair leg off",
-    "sc.kick_chair_leg.check": "Chair: {kicks} kick(s), {groups} group(s), loose pieces {before} \u2192 {after}, {leg} (expected: a loose piece appears)",
-    "sc.kick_detaches_leg_via_tool": "The kick tool (hotbar) takes a chair leg off",
-    "sc.kick_detaches_leg_via_tool.check": "Chair, kick tool: {kicks} kick(s), loose pieces {before} \u2192 {after}, {leg} (expected: a loose piece appears)",
-    "sc.screwdriver_shelf_board": "Screwdriver takes a screwed shelf board off in about 2.5 s",
-    "sc.screwdriver_shelf_board.check": "Screwdriver on the shelf board: took {secs} s, expected about {want} s, the shelf is now in {pieces}",
-    "sc.wrong_tool_refused": "The wrong tool is refused",
-    "sc.wrong_tool_refused.check": "Screwdriver on a weld: refused {refused} time(s), joints opened {opened} (expected: refused, none opened)",
-    "sc.lighter_burns_crate": "A lighter ignites a wooden crate and it ends as ash",
-    "sc.lighter_burns_crate.lit": "Lighter on the crate: burning: {lit} (expected: yes)",
-    "sc.lighter_burns_crate.ash": "After burning for 500 s: {ash} of {total} boards are ash, most charred {char}% (expected: all ash or charred)",
-    "sc.torch_melts_steel": "Wood fire does not melt a steel drum, the cutting torch does",
-    "sc.torch_melts_steel.wood": "Burning crate next to the drum: drum peaked at {peak} \xB0C, melted {melt}%, crate still burning: {crate} (expected: no melt)",
-    "sc.torch_melts_steel.torch": "Cutting torch on the drum: {temp} \xB0C, melted {melt}% (expected: melting)",
-    "sc.bucket_melts_drips": "A plastic bucket melts and drips near fire",
-    "sc.bucket_melts_drips.check": "Bucket in flames: melted {melt}%, {temp} \xB0C, {drips} drip line(s) (expected: melting)",
-    "sc.gas_bottle_explodes": "A gas bottle in a fire explodes and pushes a crate",
-    "sc.gas_bottle_explodes.explode": "Gas bottle in fire: exploded after {seconds} s (expected: explodes)",
-    "sc.gas_bottle_explodes.push": "Crate 1.3 m away: moved {moved} m, lost {lost} (expected: pushed or broken)",
-    "sc.bottle_drop_shatters": "A glass bottle dropped from 1.5 m shatters",
-    "sc.bottle_drop_shatters.check": "Bottle dropped from 1.5 m: status {status}, {cracks} cracks, water stain: {stain} (expected: broken, water on the floor)",
-    "sc.throw_chair_at_wall": "A chair thrown at the wall deals blunt damage",
-    "sc.throw_chair_at_wall.check": "Chair thrown at the wall: {impacts} impact(s), first {energy} J, {wall} damage line(s) on the wall (expected: impact and damage)",
-    "sc.coffee_three_sips": "Three sips of coffee lower the level and log caffeine",
-    "sc.coffee_three_sips.check": "Coffee: {sips} sip(s), level {before} \u2192 {after} l, caffeine logged: {caffeine}, burned the mouth: {burn} (expected: 3 sips, caffeine)",
-    "sc.tilt_cup_spills": "Tilting the cup spills coffee and leaves a stain",
-    "sc.tilt_cup_spills.check": "Cup tilted: level {before} \u2192 {after} l, {stains} coffee stain(s) (expected: spilled with a stain)",
-    "sc.jerrycan_leaks_fuel": "Shooting the jerrycan makes a leak and a fuel stain",
-    "sc.jerrycan_leaks_fuel.check": "Jerrycan shot: {streams} leak stream(s), fuel stain: {stain}, {left} l left of 20, hole line mentions the leak: {leak} (expected: leaking, stain)",
-    "sc.fuel_stain_burns": "A lit fuel stain burns",
-    "sc.fuel_stain_burns.stain": "Fuel stain on the floor after the leak: {stain} (expected: yes)",
-    "sc.fuel_stain_burns.ignite": "Lighter on the stain: {ignited} ignition(s), fire reached nearby objects: {near} (expected: ignited)",
-    "sc.fuel_stain_burns.out": "After 30 s the stain burned out: {burned} (expected: yes)",
-    "roof.standing": "roof standing",
-    "roof.fell": "roof fell",
-    "sc.one_column_roof_stands": "One column destroyed: the roof stays up",
-    "sc.one_column_roof_stands.check": "Frame with one column gone: {roof}, heaviest collapse {heavy} kg, peak stress {stress}% (expected: standing, no big collapse)",
-    "sc.two_columns_roof_collapses": "Two columns destroyed: the roof collapses",
-    "sc.two_columns_roof_collapses.check": "Frame with two columns gone: the others at {stress}% right away, then heavy loose pieces: {pieces} ({kg} kg), collapse event logged: {logged} (expected: the roof comes down)",
-    "sc.extinguisher_puts_out_fire": "The extinguisher puts out a burning crate",
-    "sc.extinguisher_puts_out_fire.burning": "Crate set on fire: burning: {burning} (expected: yes)",
-    "sc.extinguisher_puts_out_fire.out": "After the extinguisher: still burning: {burning}, {events} extinguish event(s) (expected: out)"
-  }
+// 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));
 };
-var ptBR = {
-  items: {
-    chair: "Cadeira de madeira",
-    sofa: "Sof\xE1",
-    shelf: "Estante com prateleiras",
-    old_tv: "TV antiga",
-    steel_sheet: "Chapa de a\xE7o com suporte",
-    glass_pane: "Vidro de janela",
-    concrete_block: "Bloco de concreto",
-    brick_column: "Coluna de tijolos",
-    building_frame: "Estrutura de pr\xE9dio",
-    car_door: "Porta de carro",
-    small_tree: "\xC1rvore pequena",
-    potted_plant: "Vaso de planta",
-    coffee_cup: "Copo de caf\xE9",
-    glass_bottle: "Garrafa de vidro",
-    wooden_crate: "Caixote de madeira",
-    steel_drum: "Tambor de a\xE7o",
-    plastic_bucket: "Balde de pl\xE1stico",
-    jerrycan: "Gal\xE3o",
-    gas_bottle: "Botij\xE3o de g\xE1s"
-  },
-  groups: { furniture: "M\xF3veis", structure: "Estrutura", vehicles: "Ve\xEDculos", plants: "Plantas", items: "Itens", containers: "Recipientes" },
-  text: {
-    "locale.decimal": ",",
-    yes: "sim",
-    no: "n\xE3o",
-    piece: "pe\xE7a",
-    coords: "x {x} \xB7 z {z}",
-    "count.piece.one": "1 pe\xE7a",
-    "count.piece.other": "{n} pe\xE7as",
-    "count.joint.one": "1 encaixe",
-    "count.joint.other": "{n} encaixes",
-    "count.dent.one": "1 amassado",
-    "count.dent.other": "{n} amassados",
-    "count.hole.one": "1 furo",
-    "count.hole.other": "{n} furos",
-    "count.crack.one": "1 trinca",
-    "count.crack.other": "{n} trincas",
-    "joint.generic": "junta",
-    "lost.broken": "quebrou",
-    "lost.melted": "derreteu",
-    "lost.ashes": "virou cinza",
-    "tool.none": "s\xF3 com a m\xE3o",
-    "arena.target_wall": "Parede de alvo",
-    "arena.table": "Mesa",
-    "arena.shelf": "Estante",
-    "surface.floor": "no ch\xE3o",
-    "surface.ground": "no ch\xE3o",
-    "surface.table": "na mesa",
-    "by.break": "arrebentou",
-    "by.tool": "desmontado com ferramenta",
-    "by.part_lost": "a pe\xE7a ao lado se perdeu",
-    "dmg.ballistic": "de tiro",
-    "dmg.blunt": "de impacto",
-    "dmg.slash": "de corte",
-    "dmg.explosive": "de explos\xE3o",
-    "dmg.fire": "de fogo",
-    "dmg.heat": "de calor",
-    "effect.caffeine": "cafe\xEDna",
-    "effect.alcohol": "\xE1lcool",
-    "effect.poison": "veneno",
-    "effect.disgust": "nojo",
-    "ev.dent": "{where}: amassado de {mm} mm, {hp}",
-    "ev.hole.through": "{where}: furo de {mm} mm atravessou, {hp}",
-    "ev.hole.stuck": "{where}: furo de {mm} mm n\xE3o atravessou, {hp}",
-    "ev.dents": "{where}: {n} amassados, o mais fundo com {mm} mm, {hp}",
-    "ev.holes": "{where}: {n} furos de {mm} mm, {thr} atravessaram, {hp}",
-    "ev.leak.tail": ", vazando {liquid} a {rate} l/s",
-    "ev.leak.alone": "{where}: vazando {liquid} a {rate} l/s",
-    "ev.crack": "{where}: trincou, {rays} raios de at\xE9 {cm} cm, {hp}",
-    "ev.ricochet": "{where}: a bala ricocheteou, sobraram {energy} J",
-    "ev.fracture.shatter": "{where}: estilha\xE7ou em {n} cacos",
-    "ev.fracture.crumble": "{where}: esfarelou em {n} peda\xE7os",
-    "ev.fracture.splinter": "{where}: lascou em {n} peda\xE7os",
-    "ev.fracture.tear": "{where}: rasgou em {n} retalhos",
-    "ev.fracture.snap": "{where}: partiu em {n} peda\xE7os",
-    "ev.fracture.none": "{where}: quebrou em {n} peda\xE7os",
-    "ev.detach": "{obj}: {a} soltou de {b} ({by}); o objeto agora tem {pieces}",
-    "ev.detach.many.break": "{obj}: {joints} arrebentaram; o objeto agora tem {pieces}",
-    "ev.detach.many.tool": "{obj}: {joints} soltos com ferramenta; o objeto agora tem {pieces}",
-    "ev.lost.tail": " e se soltou de {joints}; o objeto agora tem {pieces}",
-    "ev.lost.alone": "{where}: {verb} e se soltou de {joints}; o objeto agora tem {pieces}",
-    "ev.cracks": "{where}: rachando sob o peso, {n} trincas at\xE9 agora, a maior com {cm} cm, {hp}",
-    "ev.disassemble": "{obj}: soltando {kind} entre {a} e {b} com {tool}: {pct}%",
-    "ev.ignite": "{where}: pegou fogo a {temp} \xB0C",
-    "ev.ignite.many": "{obj}: {n} pe\xE7as pegaram fogo a {temp} \xB0C ({parts})",
-    "ev.extinguish": "{where}: fogo apagado",
-    "ev.extinguish.many": "{obj}: fogo apagado em {n} pe\xE7as ({parts})",
-    "ev.burnout": "{where}: virou cinza",
-    "ev.melt": "{where}: derretendo, {pct}% j\xE1 derreteu",
-    "ev.drip": "{where}: pingando material derretido",
-    "ev.explode": "{where}: explodiu, {energy} J em {radius} m",
-    "ev.destroyed": "{obj}: destru\xEDdo",
-    "ev.damage": "{where}: dano {type} de {amount}, {hp}",
-    "ev.damage.overload": "{where}: esmagado pelo peso que sustenta, perdeu {amount} hp at\xE9 agora, {hp}",
-    "ev.stress": "{where}: sobrecarregado a {stress}% da capacidade, sustentando {load} kg",
-    "ev.collapse": "{obj}: desabou, ca\xEDram {pieces} ({mass} kg): {parts}",
-    "ev.stain_ignite": "A mancha de {liquid} em x {x} \xB7 z {z} pegou fogo e vai queimar por uns {seconds} s",
-    "ev.stain_burned": "A mancha em chamas se consumiu",
-    "ev.fire_dries": "O fogo secou as manchas molhadas por perto",
-    "fl.fill": "{who}: encheu de {liquid} (+{liters} l)",
-    "fl.pour": "{who}: despejando {liquid} a {rate} l/s",
-    "fl.spill": "{who}: derramou {liquid} pela borda a {rate} l/s",
-    "fl.leak": "{who}: vazando {liquid} a {rate} l/s",
-    "fl.drink": "{who}: bebeu {liters} l, sede +{thirst}",
-    "fl.burn": "quente demais: queimou a boca",
-    "fl.empty": "{who}: vazio",
-    "fl.splash": "Respingo de {liquid}",
-    "fl.stain": "Mancha de {liquid} {surface} em {where}",
-    "fl.stains": "{n} manchas de {liquid} {surface}, a \xFAltima em {where}",
-    "fl.dried": "Uma mancha secou",
-    "fl.dried.mark": "Uma mancha secou e deixou marca",
-    "fl.dried.known": "A mancha de {liquid} {surface} em {where} secou",
-    "fl.dried.known.mark": "A mancha de {liquid} {surface} em {where} secou e deixou marca",
-    "fl.dried.many": "{n} manchas de {liquid} secaram",
-    "fl.dried.many.mark": "{n} manchas de {liquid} secaram e deixaram marca",
-    "fl.mix": "{who}: {from} misturou em {into}",
-    "act.anim_start": '{name}: anima\xE7\xE3o "{clip}" ({seconds} s)',
-    "act.anim_event": '{name}: "{clip}" evento {type}',
-    "act.anim_end": '{name}: anima\xE7\xE3o "{clip}" terminou',
-    "act.module_loaded": 'M\xF3dulo "{name}" carregado: {items} item(ns), {scenarios} cen\xE1rio(s), verifica\xE7\xF5es do contrato: {result}',
-    "mod.all_ok": "todas passaram",
-    "mod.some_failed": "algumas FALHARAM",
-    "mod.destructible_ok": "{name}: contrato de destrui\xE7\xE3o ok ({parts} pe\xE7as, golpe e estado bem formados)",
-    "mod.destructible_fail": "{name}: contrato de destrui\xE7\xE3o quebrado: {problems}",
-    "mod.animation_ok": '{name}: anima\xE7\xE3o "{clip}" ok ({seconds} s)',
-    "mod.spec_ok": "{name}: spec ok ({parts} pe\xE7as)",
-    "mod.spec_fail": "{name}: spec quebrada: {problems}",
-    "mod.spec_warn": "{name}: aviso na spec: {warning}",
-    "mod.animation_fail": '{name}: anima\xE7\xE3o "{clip}" quebrada: {problems}',
-    "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",
-    "act.tool": "Equipou {weapon}",
-    "act.shoot.hit": "{weapon}: disparo, {energy} J, acertou {where} a {dist} m",
-    "act.shoot.miss": "{weapon}: disparo, {energy} J, n\xE3o acertou nada",
-    "act.shoot.pellets": "{weapon}: disparo, {n} proj\xE9teis de at\xE9 {energy} J, {hits} acertaram {where} a {dist} m",
-    "act.melee.hit": "{weapon}: golpe, {energy} J, acertou {where} a {dist} m",
-    "act.melee.miss": "{weapon}: golpe no ar",
-    "act.flame.hit": "{weapon}: chama a {temp} \xB0C em {where}",
-    "act.flame.air": "{weapon}: chama, nada ao alcance",
-    "act.heat.hit": "{weapon}: esquentando {where} a {temp} \xB0C",
-    "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",
-    "act.tool.nojoint": "{weapon}: nenhuma junta perto de {where}",
-    "act.tool.refused": "{weapon} n\xE3o solta {kind} de {obj}; precisa de: {need}",
-    "act.extinguish.hit": "{weapon}: espuma em {what}",
-    "act.extinguish.air": "{weapon}: espuma, nada ao alcance",
-    "act.grab": "Pegou {name} ({kg} kg)",
-    "act.drop": "Soltou {name}",
-    "act.throw": "Arremessou {name} a {speed} m/s",
-    "act.landing": "{name} caiu a {speed} m/s: {energy} J",
-    "act.impact": "{name} bateu em {where} a {speed} m/s: {energy} J de dano de impacto",
-    "act.use_item": "{name}: {use}",
-    "act.tap.on": "Abriu a torneira",
-    "act.tap.off": "Fechou a torneira",
-    "use.drink": "beber",
-    "use.sip": "golinho",
-    "use.chug": "virar",
-    "use.pour": "despejar",
-    "use.pour_out": "esvaziar",
-    "use.open": "abrir",
-    "use.close": "fechar",
-    "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)",
-    "hud.empty_container": "{name} est\xE1 vazio",
-    "hud.refused": "Ferramenta errada para {kind}",
-    "hud.drop": "soltar",
-    "hud.rotate": "girar",
-    "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 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",
-    "ui.filter.check": "testes",
-    "ui.autoscroll": "rolar sozinho",
-    "log.export_cancelled": "exporta\xE7\xE3o cancelada",
-    "ui.copy_json": "Copiar JSON",
-    "ui.download_ndjson": "Baixar NDJSON",
-    "ui.download_txt": "Baixar TXT",
-    "ui.clear_log": "Limpar",
-    "ui.catalog": "Cat\xE1logo",
-    "ui.clear": "Limpar",
-    "ui.reset_all": "Consertar tudo",
-    "ui.slow": "C\xE2mera lenta 0,25\xD7",
-    "ui.fast": "Tempo \xD710",
-    "ui.tap": "Torneira",
-    "ui.blast.shelter": "Abrigo",
-    "ui.blast.fragmentHits": "Estilha\xE7os",
-    "ui.blast.confinement": "Confinamento",
-    "ui.blast.shelter.hint": "Explos\xF5es: paredes e outras partes entre a explos\xE3o e o alvo ficam com a sua parte",
-    "ui.blast.fragmentHits.hint": "Explos\xF5es: os peda\xE7os do que quebra voam e acertam o que est\xE1 atr\xE1s",
-    "ui.blast.confinement.hint": "Explos\xF5es: a press\xE3o sobe num ambiente fechado",
-    "metric.blast_shelter": "Explos\xE3o que chegou (%)",
-    "metric.blast_confinement": "Press\xE3o da explos\xE3o (x)",
-    "metric.blast_fragments": "Estilha\xE7os que acertaram",
-    "act.blast_report": "Explos\xE3o: {shelter}% chegou ao alvo mais abrigado, press\xE3o x{confinement}, {fragments} estilha\xE7os acertaram, {n} alvos",
-    "ui.quality": "Qualidade",
-    "ui.quality.low": "baixa",
-    "ui.quality.medium": "m\xE9dia",
-    "ui.quality.high": "alta",
-    "ui.equip": "Equipar como ferramenta",
-    "ui.search_items": "Buscar item (todas as abas)",
-    "ui.search_tests": "Buscar teste",
-    "ui.no_results": "Nada encontrado",
-    "ui.objects": "{n} objetos",
-    "ui.tests": "Testes",
-    "ui.run_all": "Rodar todos",
-    "ui.running": "Rodando...",
-    "ui.report": "{passed} passaram, {failed} falharam",
-    "ui.panel": "Pain\xE9is",
-    "ui.inspector": "Inspetor",
-    "ui.aim_at_something": "Mire em um objeto",
-    "ins.material": "Material",
-    "ins.status": "Estado",
-    "ins.burning": "em chamas",
-    "ins.hp": "Pontos de vida",
-    "ins.temperature": "Temperatura",
-    "ins.char": "Carbonizado",
-    "ins.melt": "Derretido",
-    "ins.liters": "L\xEDquido",
-    "ins.damage": "Marcas",
-    "ins.damage_counts": "{dents}, {holes}, {cracks}",
-    "ins.mass": "Massa",
-    "ins.load": "Carga",
-    "ins.stress": "Tens\xE3o",
-    "ins.joints": "Juntas",
-    "ins.open": "aberta",
-    "sc.start": "Cen\xE1rio: {name}",
-    "sc.pass": "Cen\xE1rio passou: {name}",
-    "sc.fail": "Cen\xE1rio FALHOU: {name}",
-    "sc.error": "o cen\xE1rio lan\xE7ou um erro: {msg}",
-    "leg.still": "leg_1 continua presa",
-    "leg.gone": "leg_1 soltou",
-    "sc.steel_through_hole": "Tiro de 9 mm em chapa de a\xE7o faz furo que atravessa",
-    "sc.steel_through_hole.check": "9 mm em a\xE7o de 3 mm: {holes} furo(s) de {mm} mm, atravessou: {through}, chapa com {hp} hp (esperado: atravessar)",
-    "sc.concrete_stops_bullet": "Tiro de 9 mm em bloco de concreto n\xE3o atravessa",
-    "sc.concrete_stops_bullet.check": "9 mm em 40 cm de concreto: atravessou: {through}, {dents}, {holes}, {cracks}, bloco com {hp} hp (esperado: parou, parede atr\xE1s intacta)",
-    "sc.hammer_dents_drum": "Martelo amassa um tambor de a\xE7o",
-    "sc.hammer_dents_drum.check": "Martelo no tambor: {swings} golpe(s), {dents} amassado(s), o primeiro com {depth} mm, corpo com {hp} hp (esperado: amassado, sem quebrar)",
-    "sc.glass_shatters": "Vidro estilha\xE7a no primeiro tiro de 9 mm",
-    "sc.glass_shatters.check": "Vidro: quebrou depois de {shots} tiro(s) em {n} cacos (esperado: quebrado no primeiro tiro, pelo menos 4 cacos)",
-    "sc.shotgun_splinters_crate": "Escopeta lasca um caixote de madeira",
-    "sc.shotgun_splinters_crate.check": "Calibre 12 no caixote: {shots} tiro(s), {splinters} t\xE1bua(s) lascada(s), {holes} furos (esperado: pelo menos uma lascada)",
-    "sc.kick_chair_leg": "Um chute solta a perna da cadeira",
-    "sc.kick_chair_leg.check": "Cadeira: {kicks} chute(s), {groups} grupo(s), pe\xE7as soltas {before} \u2192 {after}, {leg} (esperado: aparece uma pe\xE7a solta)",
-    "sc.kick_detaches_leg_via_tool": "A ferramenta chute (barra de atalhos) solta a perna da cadeira",
-    "sc.kick_detaches_leg_via_tool.check": "Cadeira, ferramenta chute: {kicks} chute(s), pe\xE7as soltas {before} \u2192 {after}, {leg} (esperado: aparece uma pe\xE7a solta)",
-    "sc.screwdriver_shelf_board": "Chave de fenda solta a prateleira parafusada em cerca de 2,5 s",
-    "sc.screwdriver_shelf_board.check": "Chave de fenda na prateleira: levou {secs} s, esperado cerca de {want} s, a estante agora est\xE1 em {pieces}",
-    "sc.wrong_tool_refused": "A ferramenta errada \xE9 recusada",
-    "sc.wrong_tool_refused.check": "Chave de fenda numa solda: recusou {refused} vez(es), juntas abertas {opened} (esperado: recusar, nenhuma aberta)",
-    "sc.lighter_burns_crate": "Isqueiro acende o caixote de madeira e ele vira cinza",
-    "sc.lighter_burns_crate.lit": "Isqueiro no caixote: pegou fogo: {lit} (esperado: sim)",
-    "sc.lighter_burns_crate.ash": "Depois de queimar por 500 s: {ash} de {total} t\xE1buas viraram cinza, a mais queimada {char}% (esperado: tudo cinza ou carbonizado)",
-    "sc.torch_melts_steel": "Fogo de madeira n\xE3o derrete o tambor de a\xE7o, o ma\xE7arico derrete",
-    "sc.torch_melts_steel.wood": "Caixote em chamas ao lado do tambor: o tambor chegou a {peak} \xB0C, derreteu {melt}%, caixote ainda queimando: {crate} (esperado: sem derreter)",
-    "sc.torch_melts_steel.torch": "Ma\xE7arico no tambor: {temp} \xB0C, derreteu {melt}% (esperado: derretendo)",
-    "sc.bucket_melts_drips": "Balde de pl\xE1stico derrete e pinga perto do fogo",
-    "sc.bucket_melts_drips.check": "Balde nas chamas: derreteu {melt}%, {temp} \xB0C, {drips} linha(s) de pingos (esperado: derretendo)",
-    "sc.gas_bottle_explodes": "Botij\xE3o de g\xE1s no fogo explode e empurra um caixote",
-    "sc.gas_bottle_explodes.explode": "Botij\xE3o no fogo: explodiu depois de {seconds} s (esperado: explode)",
-    "sc.gas_bottle_explodes.push": "Caixote a 1,3 m: andou {moved} m, perdeu {lost} (esperado: empurrado ou quebrado)",
-    "sc.bottle_drop_shatters": "Garrafa de vidro solta de 1,5 m estilha\xE7a",
-    "sc.bottle_drop_shatters.check": "Garrafa solta de 1,5 m: estado {status}, {cracks} trincas, mancha de \xE1gua: {stain} (esperado: quebrada, \xE1gua no ch\xE3o)",
-    "sc.throw_chair_at_wall": "Cadeira arremessada na parede causa dano de impacto",
-    "sc.throw_chair_at_wall.check": "Cadeira na parede: {impacts} impacto(s), o primeiro com {energy} J, {wall} linha(s) de dano na parede (esperado: impacto e dano)",
-    "sc.coffee_three_sips": "Tr\xEAs goles de caf\xE9 baixam o n\xEDvel e registram cafe\xEDna",
-    "sc.coffee_three_sips.check": "Caf\xE9: {sips} gole(s), n\xEDvel {before} \u2192 {after} l, cafe\xEDna registrada: {caffeine}, queimou a boca: {burn} (esperado: 3 goles, cafe\xEDna)",
-    "sc.tilt_cup_spills": "Inclinar o copo derrama caf\xE9 e deixa mancha",
-    "sc.tilt_cup_spills.check": "Copo inclinado: n\xEDvel {before} \u2192 {after} l, {stains} mancha(s) de caf\xE9 (esperado: derramou com mancha)",
-    "sc.jerrycan_leaks_fuel": "Tiro no gal\xE3o faz vazamento e mancha de combust\xEDvel",
-    "sc.jerrycan_leaks_fuel.check": "Gal\xE3o baleado: {streams} jato(s) de vazamento, mancha de combust\xEDvel: {stain}, restam {left} l de 20, a linha do furo cita o vazamento: {leak} (esperado: vazando, mancha)",
-    "sc.fuel_stain_burns": "Mancha de combust\xEDvel acesa queima",
-    "sc.fuel_stain_burns.stain": "Mancha de combust\xEDvel no ch\xE3o depois do vazamento: {stain} (esperado: sim)",
-    "sc.fuel_stain_burns.ignite": "Isqueiro na mancha: {ignited} igni\xE7\xE3o(\xF5es), o fogo alcan\xE7ou objetos por perto: {near} (esperado: acendeu)",
-    "sc.fuel_stain_burns.out": "Depois de 30 s a mancha se consumiu: {burned} (esperado: sim)",
-    "roof.standing": "laje de p\xE9",
-    "roof.fell": "laje caiu",
-    "sc.one_column_roof_stands": "Pilar destru\xEDdo: a laje fica de p\xE9",
-    "sc.one_column_roof_stands.check": "Estrutura sem um pilar: {roof}, maior desabamento {heavy} kg, tens\xE3o m\xE1xima {stress}% (esperado: de p\xE9, sem desabamento grande)",
-    "sc.two_columns_roof_collapses": "Dois pilares destru\xEDdos: a laje desaba",
-    "sc.two_columns_roof_collapses.check": "Estrutura sem dois pilares: os outros logo a {stress}%, depois pe\xE7as pesadas soltas: {pieces} ({kg} kg), evento de desabamento registrado: {logged} (esperado: a laje desaba)",
-    "sc.extinguisher_puts_out_fire": "Extintor apaga um caixote em chamas",
-    "sc.extinguisher_puts_out_fire.burning": "Caixote incendiado: queimando: {burning} (esperado: sim)",
-    "sc.extinguisher_puts_out_fire.out": "Depois do extintor: ainda queimando: {burning}, {events} evento(s) de apagar (esperado: apagado)"
-  }
+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 locales = { en, "pt-BR": ptBR };
-var resolveStrings = (locale) => locales[locale ?? "en"] ?? locales.en;
-
-// src/items.ts
-var DEMO_MATERIALS = [];
-var box = (id, material, size, position, extra = {}) => ({ id, material, shape: { kind: "box", size }, position, ...extra });
-var cyl = (id, material, radius, height, position, extra = {}) => ({
-  id,
-  material,
-  shape: { kind: "cylinder", radius, height },
-  position,
-  ...extra
-});
-var sph = (id, material, radius, position, extra = {}) => ({ id, material, shape: { kind: "sphere", radius }, position, ...extra });
-var joint = (a, b, kind, extra = {}) => ({ a, b, kind, ...extra });
-function brickWallSpec(cols = 8, rows = 6, panel = [1.25, 0.5, 0.2]) {
-  const parts = [];
-  const joints = [];
-  const id = (c, r) => `brick_${r}_${c}`;
-  for (let r = 0; r < rows; r++) {
-    for (let c = 0; c < cols; c++) {
-      parts.push(box(id(c, r), "brick", panel, [(c - (cols - 1) / 2) * panel[0], panel[1] / 2 + r * panel[1], 0], { anchored: r === 0 }));
-      if (c > 0) joints.push(joint(id(c - 1, r), id(c, r), "mortar"));
-      if (r > 0) joints.push(joint(id(c, r - 1), id(c, r), "mortar"));
+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 { name: "brick wall", parts, joints, tags: ["structure"] };
-}
-var chair = () => {
-  const legs = [
-    [-0.18, -0.18],
-    [0.18, -0.18],
-    [-0.18, 0.18],
-    [0.18, 0.18]
-  ];
-  return {
-    name: "chair",
-    parts: [
-      box("seat", "wood_soft", [0.42, 0.04, 0.42], [0, 0.45, 0]),
-      ...legs.map(([x, z], i) => box(`leg_${i + 1}`, "wood_soft", [0.04, 0.43, 0.04], [x, 0.215, z])),
-      box("backrest", "wood_soft", [0.4, 0.3, 0.03], [0, 0.64, -0.195])
-    ],
-    joints: [...legs.map((_, i) => joint(`leg_${i + 1}`, "seat", "screw")), joint("backrest", "seat", "screw")],
-    tags: ["furniture"]
-  };
-};
-var crate = () => ({
-  name: "wooden crate",
-  parts: [
-    box("front", "wood_soft", [0.5, 0.5, 0.02], [0, 0.25, 0.24], { hp: 70 }),
-    box("back", "wood_soft", [0.5, 0.5, 0.02], [0, 0.25, -0.24], { hp: 70 }),
-    box("left", "wood_soft", [0.02, 0.5, 0.46], [-0.24, 0.25, 0], { hp: 70 }),
-    box("right", "wood_soft", [0.02, 0.5, 0.46], [0.24, 0.25, 0], { hp: 70 }),
-    box("bottom", "wood_soft", [0.46, 0.02, 0.46], [0, 0.01, 0], { hp: 70 })
-  ],
-  joints: [
-    joint("front", "left", "nail"),
-    joint("front", "right", "nail"),
-    joint("back", "left", "nail"),
-    joint("back", "right", "nail"),
-    joint("front", "bottom", "nail"),
-    joint("back", "bottom", "nail"),
-    joint("left", "bottom", "nail"),
-    joint("right", "bottom", "nail")
-  ],
-  tags: ["container"]
-});
-var drum = () => ({
-  name: "steel drum",
-  parts: [
-    cyl("drum_body", "steel", 0.29, 0.86, [0, 0.45, 0], { mass: 12, thickness: 12e-4 }),
-    cyl("drum_top", "steel", 0.29, 0.02, [0, 0.89, 0], { mass: 1.5, thickness: 12e-4 }),
-    cyl("drum_bottom", "steel", 0.29, 0.02, [0, 0.01, 0], { mass: 1.5, thickness: 12e-4 })
-  ],
-  joints: [joint("drum_body", "drum_top", "weld"), joint("drum_body", "drum_bottom", "weld")],
-  tags: ["container"]
-});
-var steelSheet = () => ({
-  name: "steel sheet",
-  parts: [
-    box("sheet", "steel", [1, 1, 3e-3], [0, 1.1, 0]),
-    box("post_l", "steel", [0.04, 0.54, 0.04], [-0.35, 0.33, 0], { mass: 4 }),
-    box("post_r", "steel", [0.04, 0.54, 0.04], [0.35, 0.33, 0], { mass: 4 }),
-    box("foot_l", "steel", [0.06, 0.06, 0.5], [-0.35, 0.03, 0], { mass: 6 }),
-    box("foot_r", "steel", [0.06, 0.06, 0.5], [0.35, 0.03, 0], { mass: 6 })
-  ],
-  joints: [joint("sheet", "post_l", "weld"), joint("sheet", "post_r", "weld"), joint("post_l", "foot_l", "weld"), joint("post_r", "foot_r", "weld")],
-  tags: ["structure"]
-});
-var glassPane = () => ({
-  name: "glass pane",
-  parts: [
-    box("pane", "glass", [0.8, 1, 6e-3], [0, 1.05, 0], { hp: 40 }),
-    box("frame_top", "aluminium", [0.88, 0.04, 0.04], [0, 1.57, 0], { mass: 1 }),
-    box("frame_bottom", "aluminium", [0.88, 0.04, 0.04], [0, 0.53, 0], { mass: 1 }),
-    box("frame_l", "aluminium", [0.04, 1.04, 0.04], [-0.42, 1.05, 0], { mass: 1 }),
-    box("frame_r", "aluminium", [0.04, 1.04, 0.04], [0.42, 1.05, 0], { mass: 1 }),
-    box("foot_l", "steel", [0.06, 0.5, 0.4], [-0.35, 0.25, 0], { mass: 5 }),
-    box("foot_r", "steel", [0.06, 0.5, 0.4], [0.35, 0.25, 0], { mass: 5 })
-  ],
-  joints: [
-    joint("pane", "frame_top", "clip"),
-    joint("pane", "frame_bottom", "clip"),
-    joint("pane", "frame_l", "clip"),
-    joint("pane", "frame_r", "clip"),
-    joint("frame_bottom", "foot_l", "bolt"),
-    joint("frame_bottom", "foot_r", "bolt"),
-    joint("frame_l", "frame_top", "weld"),
-    joint("frame_r", "frame_top", "weld"),
-    joint("frame_l", "frame_bottom", "weld"),
-    joint("frame_r", "frame_bottom", "weld")
-  ],
-  tags: ["structure"]
-});
-var concreteBlock = () => ({
-  name: "concrete block",
-  parts: [box("block", "concrete", [0.4, 0.4, 0.4], [0, 0.2, 0])],
-  tags: ["structure"]
-});
-var brickColumn = () => {
-  const parts = [];
-  const joints = [];
-  const layers = 8;
-  const id = (l, x, z) => `brick_${l}_${x}${z}`;
-  for (let l = 0; l < layers; l++) {
-    for (let x = 0; x < 2; x++) {
-      for (let z = 0; z < 2; z++) {
-        parts.push(box(id(l, x, z), "brick", [0.2, 0.2, 0.2], [(x - 0.5) * 0.2, 0.1 + l * 0.2, (z - 0.5) * 0.2], { anchored: l === 0 }));
-        if (x > 0) joints.push(joint(id(l, x - 1, z), id(l, x, z), "mortar"));
-        if (z > 0) joints.push(joint(id(l, x, z - 1), id(l, x, z), "mortar"));
-        if (l > 0) joints.push(joint(id(l - 1, x, z), id(l, x, z), "mortar"));
-      }
-    }
-  }
-  return { name: "brick column", parts, joints, tags: ["structure"] };
-};
-var frame = () => ({ ...buildFrame({ spanX: 4, spanZ: 4, columnsX: 2, columnsZ: 2, height: 2.8, floors: 1, walls: false, roof: true, columnCapacity: 4400 }), name: "building frame" });
-var bucket = () => ({
-  name: "plastic bucket",
-  parts: [
-    cyl("bucket_body", "plastic", 0.14, 0.28, [0, 0.14, 0], { mass: 0.5, thickness: 2e-3 }),
-    box("handle", "plastic", [0.3, 0.012, 0.012], [0, 0.3, 0], { mass: 0.05 })
-  ],
-  joints: [joint("handle", "bucket_body", "clip")],
-  tags: ["container"]
-});
-var bottle = () => ({
-  name: "glass bottle",
-  parts: [
-    cyl("bottle_body", "glass", 0.037, 0.17, [0, 0.085, 0], { mass: 0.3, thickness: 3e-3, contains: { fluid: "water", liters: 0.5 } }),
-    cyl("bottle_neck", "glass", 0.015, 0.09, [0, 0.215, 0], { mass: 0.08, thickness: 2e-3 })
-  ],
-  joints: [joint("bottle_neck", "bottle_body", "fused")],
-  tags: ["item"]
-});
-var cup = () => ({
-  name: "coffee cup",
-  parts: [
-    cyl("cup", "ceramic", 0.05, 0.11, [0, 0.055, 0], { mass: 0.3, thickness: 4e-3, contains: { fluid: "coffee", liters: 0.25 } }),
-    box("cup_handle", "ceramic", [0.02, 0.06, 0.014], [0.068, 0.06, 0], { mass: 0.04 })
-  ],
-  joints: [joint("cup_handle", "cup", "fused")],
-  tags: ["item"]
-});
-var jerrycan = () => ({
-  name: "jerrycan",
-  parts: [
-    box("tank", "plastic", [0.34, 0.45, 0.14], [0, 0.225, 0], { mass: 1.2, thickness: 3e-3, contains: { fluid: "fuel", liters: 20 } }),
-    cyl("cap", "plastic", 0.025, 0.03, [0.08, 0.465, 0], { mass: 0.05 }),
-    box("handle", "plastic", [0.1, 0.03, 0.03], [-0.07, 0.465, 0], { mass: 0.1 })
-  ],
-  joints: [joint("cap", "tank", "screw"), joint("handle", "tank", "fused")],
-  tags: ["container"]
-});
-var gasBottle = () => ({
-  name: "gas bottle",
-  parts: [
-    cyl("cylinder", "steel", 0.15, 0.7, [0, 0.4, 0], {
-      mass: 11,
-      thickness: 3e-3,
-      contains: { fluid: "gas", liters: 13, pressurized: true },
-      explodes: { energy: 12e4, radius: 5, atC: 300 }
-    }),
-    cyl("valve", "steel", 0.03, 0.1, [0, 0.8, 0], { mass: 0.5 }),
-    cyl("foot_ring", "steel", 0.14, 0.05, [0, 0.025, 0], { mass: 1 })
-  ],
-  joints: [joint("valve", "cylinder", "weld"), joint("foot_ring", "cylinder", "weld")],
-  tags: ["container"]
-});
-var tree = () => ({
-  name: "small tree",
-  parts: [
-    cyl("trunk", "green_wood", 0.08, 2.2, [0, 1.1, 0], { anchored: true }),
-    cyl("branch_1", "green_wood", 0.03, 0.8, [0.34, 1.7, 0], { rotation: [0, 0, -0.9] }),
-    cyl("branch_2", "green_wood", 0.03, 0.8, [-0.3, 1.9, 0.12], { rotation: [0, 0, 0.8] }),
-    cyl("branch_3", "green_wood", 0.025, 0.7, [0.05, 2, -0.28], { rotation: [0.8, 0, 0] }),
-    sph("crown_top", "foliage", 0.55, [0, 2.55, 0], { mass: 2 }),
-    sph("crown_1", "foliage", 0.38, [0.62, 2, 0], { mass: 1 }),
-    sph("crown_2", "foliage", 0.38, [-0.58, 2.2, 0.15], { mass: 1 }),
-    sph("crown_3", "foliage", 0.32, [0.05, 2.3, -0.55], { mass: 1 })
-  ],
-  joints: [
-    joint("branch_1", "trunk", "stem"),
-    joint("branch_2", "trunk", "stem"),
-    joint("branch_3", "trunk", "stem"),
-    joint("crown_top", "trunk", "stem"),
-    joint("crown_1", "branch_1", "stem"),
-    joint("crown_2", "branch_2", "stem"),
-    joint("crown_3", "branch_3", "stem")
-  ],
-  tags: ["plant"]
-});
-var pottedPlant = () => ({
-  name: "potted plant",
-  parts: [
-    cyl("pot", "ceramic", 0.15, 0.25, [0, 0.125, 0], { mass: 2, thickness: 8e-3 }),
-    cyl("soil", "soil", 0.14, 0.06, [0, 0.26, 0], { mass: 1.5 }),
-    sph("leaves_1", "foliage", 0.16, [0, 0.46, 0], { mass: 0.3 }),
-    sph("leaves_2", "foliage", 0.12, [0.12, 0.38, 0.04], { mass: 0.2 }),
-    sph("leaves_3", "foliage", 0.12, [-0.1, 0.4, -0.06], { mass: 0.2 })
-  ],
-  joints: [joint("soil", "pot", "fused"), joint("leaves_1", "soil", "stem"), joint("leaves_2", "soil", "stem"), joint("leaves_3", "soil", "stem")],
-  tags: ["plant"]
-});
-var oldTv = () => ({
-  name: "old TV",
-  parts: [
-    box("stand", "wood_soft", [0.6, 0.35, 0.42], [0, 0.175, 0]),
-    box("shell", "plastic", [0.58, 0.44, 0.42], [0, 0.57, 0], { mass: 3, thickness: 4e-3 }),
-    box("screen", "glass", [0.42, 0.32, 0.012], [0, 0.57, 0.212], { mass: 1.5 }),
-    box("coil", "copper", [0.2, 0.1, 0.2], [0, 0.55, -0.05], { mass: 1.5 })
-  ],
-  joints: [joint("shell", "stand", "screw"), joint("screen", "shell", "clip"), joint("coil", "shell", "screw")],
-  tags: ["furniture"]
-});
-var carDoor = () => ({
-  name: "car door",
-  parts: [
-    box("post", "steel", [0.1, 1.3, 0.1], [-0.58, 0.65, 0], { mass: 12, anchored: true }),
-    box("skin", "steel", [1, 0.8, 0.05], [0, 0.75, 0], { mass: 14, thickness: 8e-4 }),
-    box("window", "glass", [0.78, 0.32, 0.01], [0.04, 1.31, 0.01], { mass: 3 }),
-    box("seal", "rubber", [0.84, 0.03, 0.03], [0.04, 1.14, 0.01], { mass: 0.3 })
-  ],
-  joints: [
-    joint("skin", "post", "hinge", { id: "hinge_upper" }),
-    joint("skin", "post", "hinge", { id: "hinge_lower" }),
-    joint("window", "seal", "clip"),
-    joint("seal", "skin", "clip")
-  ],
-  tags: ["vehicle"]
-});
-var sofa = () => ({
-  name: "sofa",
-  parts: [
-    box("frame", "wood_soft", [1.8, 0.3, 0.8], [0, 0.15, 0], { mass: 14 }),
-    box("seat_cushion", "foam", [1.5, 0.18, 0.62], [0, 0.39, 0.06], { mass: 4 }),
-    box("back_cushion", "foam", [1.5, 0.5, 0.16], [0, 0.65, -0.3], { mass: 4 }),
-    box("arm_l", "fabric", [0.15, 0.4, 0.8], [-0.82, 0.5, 0], { mass: 3 }),
-    box("arm_r", "fabric", [0.15, 0.4, 0.8], [0.82, 0.5, 0], { mass: 3 })
-  ],
-  joints: [
-    joint("seat_cushion", "frame", "clip"),
-    joint("back_cushion", "frame", "clip"),
-    joint("arm_l", "frame", "screw"),
-    joint("arm_r", "frame", "screw")
-  ],
-  tags: ["furniture"]
-});
-var shelf = () => ({
-  name: "shelf",
-  parts: [
-    box("back", "plywood", [0.84, 1.5, 0.012], [0, 0.75, -0.14], { anchored: true }),
-    box("board_1", "wood_soft", [0.8, 0.025, 0.28], [0, 0.35, 0]),
-    box("board_2", "wood_soft", [0.8, 0.025, 0.28], [0, 0.75, 0]),
-    box("board_3", "wood_soft", [0.8, 0.025, 0.28], [0, 1.15, 0]),
-    box("board_4", "wood_soft", [0.8, 0.025, 0.28], [0, 1.5, 0])
-  ],
-  joints: [joint("board_1", "back", "screw"), joint("board_2", "back", "screw"), joint("board_3", "back", "screw"), joint("board_4", "back", "screw")],
-  tags: ["furniture"]
-});
-var DEFS = [
-  { id: "chair", group: "furniture", spec: chair, colors: { wood_soft: 11038778 } },
-  { id: "sofa", group: "furniture", spec: sofa, colors: { frame: 7029798, seat_cushion: 8207180, back_cushion: 8207180, arm_l: 6958912, arm_r: 6958912 } },
-  { id: "shelf", group: "furniture", spec: shelf, colors: { back: 14272931 }, movable: false },
-  { id: "old_tv", group: "furniture", spec: oldTv, colors: { shell: 7166526, stand: 9067056, screen: 5205864 } },
-  { id: "steel_sheet", group: "structure", spec: steelSheet, movable: false, colors: { sheet: 11910340 } },
-  { id: "glass_pane", group: "structure", spec: glassPane, movable: false },
-  { id: "concrete_block", group: "structure", spec: concreteBlock },
-  { id: "brick_column", group: "structure", spec: brickColumn, movable: false },
-  { id: "building_frame", group: "structure", spec: frame, movable: false, colors: { roof: 8224121 } },
-  { id: "car_door", group: "vehicles", spec: carDoor, movable: false, colors: { skin: 12597547, window: 10278630 } },
-  { id: "small_tree", group: "plants", spec: tree, movable: false },
-  { id: "potted_plant", group: "plants", spec: pottedPlant, colors: { pot: 12871482 } },
-  { id: "coffee_cup", group: "items", spec: cup, colors: { cup: 15986662 }, fluid: { container: { capacity: 0.6, liquid: "coffee", liters: 0.25, temperature: 80, shape: { kind: "cylinder", radius: 0.045, height: 0.1 }, opening: 0.045 }, part: "cup", uses: ["drink", "sip", "pour"], offset: [0, 0.01, 0] } },
-  {
-    id: "glass_bottle",
-    group: "items",
-    spec: bottle,
-    colors: { bottle_body: 8378032, bottle_neck: 8378032 },
-    fluid: { container: { capacity: 0.5, liquid: "water", liters: 0.5, temperature: 18, shape: { kind: "cylinder", radius: 0.034, height: 0.14 }, opening: 0.012 }, part: "bottle_body", uses: ["drink", "sip", "pour"], offset: [0, 0.015, 0] }
-  },
-  { id: "wooden_crate", group: "containers", spec: crate },
-  { id: "steel_drum", group: "containers", spec: drum, colors: { drum_body: 2842526, drum_top: 2842526, drum_bottom: 2842526 } },
-  { id: "plastic_bucket", group: "containers", spec: bucket, colors: { bucket_body: 14239787, handle: 9079434 } },
-  {
-    id: "jerrycan",
-    group: "containers",
-    spec: jerrycan,
-    colors: { tank: 12729122, cap: 15909424, handle: 12729122 },
-    fluid: { container: { capacity: 20, liquid: "fuel", liters: 20, temperature: 20, shape: { kind: "box", size: [0.33, 0.44, 0.13] }, opening: 0.025, closed: true }, part: "tank", uses: ["pour", "open", "close"], offset: [0, 8e-3, 0] }
-  },
-  { id: "gas_bottle", group: "containers", spec: gasBottle, colors: { cylinder: 14211280, valve: 7829367, foot_ring: 5592405 } }
-];
-function demoItems(locale = "en", extra = []) {
-  const s = resolveStrings(locale);
-  const out = DEFS.map((d) => ({
-    id: d.id,
-    name: s.items[d.id] ?? d.id,
-    group: s.groups[d.group] ?? d.group,
-    build: (THREE) => buildFromSpec(THREE, d.spec(), { colors: d.colors }),
-    spec: d.spec,
-    movable: d.movable,
-    fluid: d.fluid
-  }));
-  return [...out, ...extra];
-}
-var DEMO_ITEMS = demoItems("en");
-
-// src/arena.ts
-var tableSpec = () => {
-  const parts = [{ id: "top", material: "wood_hard", shape: { kind: "box", size: [1.6, 0.05, 0.8] }, position: [0, 0.755, 0] }];
-  const joints = [];
-  for (const [i, [x, z]] of [
-    [-0.72, -0.32],
-    [0.72, -0.32],
-    [-0.72, 0.32],
-    [0.72, 0.32]
-  ].entries()) {
-    parts.push({ id: `leg_${i + 1}`, material: "wood_hard", shape: { kind: "box", size: [0.06, 0.73, 0.06] }, position: [x, 0.365, z], anchored: true });
-    joints.push({ a: `leg_${i + 1}`, b: "top", kind: "screw" });
-  }
-  return { name: "table", parts, joints, tags: ["furniture"] };
-};
-var shelfSpec = () => {
-  const parts = [];
-  const joints = [];
-  for (const [i, x] of [-0.6, 0.6].entries()) {
-    parts.push({ id: `upright_${i + 1}`, material: "wood_hard", shape: { kind: "box", size: [0.04, 1.7, 0.4] }, position: [x, 0.85, 0], anchored: true });
-  }
-  for (const [i, y] of [0.4, 0.9, 1.4].entries()) {
-    parts.push({ id: `board_${i + 1}`, material: "wood_soft", shape: { kind: "box", size: [1.2, 0.03, 0.4] }, position: [0, y, 0] });
-    joints.push({ a: `board_${i + 1}`, b: "upright_1", kind: "screw" }, { a: `board_${i + 1}`, b: "upright_2", kind: "screw" });
-  }
-  return { name: "shelf", parts, joints, tags: ["furniture"] };
-};
-function createArena(THREE, size, scene) {
-  const group = new THREE.Group();
-  group.name = "test-room-arena";
-  scene.background = new THREE.Color(10466504);
-  group.add(new THREE.HemisphereLight(13624319, 7037527, 0.75));
-  const sun = new THREE.DirectionalLight(16777215, 2.1);
-  sun.position.set(7, 13, 8);
-  sun.castShadow = true;
-  sun.shadow.mapSize.set(1024, 1024);
-  const sc = sun.shadow.camera;
-  sc.left = -16;
-  sc.right = 16;
-  sc.top = 16;
-  sc.bottom = -16;
-  sc.near = 1;
-  sc.far = 40;
-  sun.shadow.bias = -6e-4;
-  group.add(sun);
-  const floor = new THREE.Mesh(new THREE.PlaneGeometry(size * 2, size * 2), new THREE.MeshStandardMaterial({ color: 9342602, roughness: 0.95 }));
-  floor.rotation.x = -Math.PI / 2;
-  floor.receiveShadow = true;
-  floor.name = "floor";
-  group.add(floor);
-  const grid = new THREE.GridHelper(size * 2, size * 2, 5000274, 7829371);
-  grid.position.y = 4e-3;
-  group.add(grid);
-  const wallZ = -11;
-  const playerStart = [0, 1.7, 5];
-  const pts = [];
-  const rx = -1.6;
-  for (let z = Math.round(playerStart[2]); z >= wallZ; z--) {
-    const d = playerStart[2] - z;
-    const len = d % 5 === 0 ? 0.5 : 0.2;
-    pts.push(rx, 0.01, z, rx + len, 0.01, z);
-  }
-  pts.push(rx, 0.01, playerStart[2], rx, 0.01, wallZ);
-  const rg = new THREE.BufferGeometry();
-  rg.setAttribute("position", new THREE.Float32BufferAttribute(pts, 3));
-  group.add(new THREE.LineSegments(rg, new THREE.LineBasicMaterial({ color: 16765503 })));
-  for (let d = 5; playerStart[2] - d >= wallZ; d += 5) {
-    try {
-      const canvas = document.createElement("canvas");
-      canvas.width = 128;
-      canvas.height = 64;
-      const ctx = canvas.getContext("2d");
-      if (!ctx) break;
-      ctx.fillStyle = "#ffd23f";
-      ctx.font = "bold 44px sans-serif";
-      ctx.textAlign = "center";
-      ctx.fillText(`${d} m`, 64, 48);
-      const sprite = new THREE.Sprite(new THREE.SpriteMaterial({ map: new THREE.CanvasTexture(canvas), transparent: true, depthWrite: false }));
-      sprite.scale.set(1.2, 0.6, 1);
-      sprite.position.set(rx - 0.8, 0.45, playerStart[2] - d);
-      group.add(sprite);
-    } catch {
-      break;
-    }
-  }
-  const tableX = 3.5;
-  const tapMat = new THREE.MeshStandardMaterial({ color: 12172996, metalness: 0.8, roughness: 0.35 });
-  const post = new THREE.Mesh(new THREE.CylinderGeometry(0.04, 0.04, 1.4, 10), tapMat);
-  post.position.set(tableX + 1.15, 0.7, 0);
-  const arm = new THREE.Mesh(new THREE.CylinderGeometry(0.025, 0.025, 1.15 - 0.3, 10), tapMat);
-  arm.rotation.z = Math.PI / 2;
-  arm.position.set(tableX + (1.15 + 0.3) / 2, 1.38, 0);
-  const spoutMesh = new THREE.Mesh(new THREE.CylinderGeometry(0.025, 0.025, 0.1, 10), tapMat);
-  spoutMesh.position.set(tableX + 0.3, 1.33, 0);
-  for (const m of [post, arm, spoutMesh]) {
-    m.castShadow = true;
-    group.add(m);
-  }
-  const tapSpout = [tableX + 0.3, 1.28, 0];
-  const objects = [
-    { id: "target_wall", spec: brickWallSpec(), position: [0, 0, wallZ], colors: { brick: 10831662 } },
-    { id: "table", spec: tableSpec(), position: [tableX, 0, 0] },
-    { id: "shelf", spec: shelfSpec(), position: [-3.5, 0, 0], colors: { wood_soft: 13081186 } }
-  ];
-  return {
-    group,
-    objects,
-    surfaces: [
-      { id: "floor", point: [0, 0, 0], normal: [0, 1, 0], halfSize: [size, size], porosity: 0.05 },
-      { id: "table", point: [tableX, 0.78, 0], normal: [0, 1, 0], halfSize: [0.8, 0.4], porosity: 0.3 }
-    ],
-    colliders: [
-      [tableX - 0.8, -0.4, tableX + 0.8, 0.4],
-      [tableX + 1.1, -0.1, tableX + 1.2, 0.1],
-      [-3.5 - 0.62, -0.2, -3.5 + 0.62, 0.2],
-      [-size, wallZ - 1, size, wallZ + 0.2]
-    ],
-    playerStart,
-    wallZ,
-    table: { minX: tableX - 0.8, maxX: tableX + 0.8, minZ: -0.4, maxZ: 0.4, top: 0.78, id: "table", topPart: "top" },
-    tapSpout,
-    sun
-  };
-}
-
-// 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;
+  return out;
 }
 function createBenchStore(module, locale, onListenerError) {
   const declared = { controls: module.controls?.(locale) ?? [], layers: module.layers?.(locale) ?? [], metrics: module.metrics?.(locale) ?? [] };
@@ -1365,6 +392,81 @@ function createBenchStore(module, locale, onListenerError) {
   return store;
 }
 
+// src/build-from-spec.ts
+var MATERIAL_COLORS = {
+  steel: 9278620,
+  cast_iron: 4869458,
+  aluminium: 12896718,
+  copper: 12088122,
+  wood_soft: 12158287,
+  wood_hard: 8014374,
+  plywood: 13214826,
+  mdf: 11045732,
+  glass: 10278630,
+  tempered_glass: 10278630,
+  ceramic: 15328474,
+  concrete: 10132118,
+  brick: 10831662,
+  plaster: 15131092,
+  stone: 7828591,
+  plastic: 3897540,
+  rubber: 2039586,
+  fabric: 9063262,
+  foam: 14926936,
+  leather: 5978662,
+  paper: 15657695,
+  foliage: 4165434,
+  green_wood: 7031339,
+  cactus: 4095306,
+  flesh_fruit: 13781810,
+  wax: 15721141,
+  soil: 4862754
+};
+var TRANSPARENT = { glass: 0.38, tempered_glass: 0.38 };
+function buildFromSpec(THREE, spec, options = {}) {
+  const root = new THREE.Group();
+  root.name = spec.name ?? "object";
+  const seg = options.segments ?? 12;
+  const shadows = options.shadows !== false;
+  const mats = /* @__PURE__ */ new Map();
+  const materialFor = (p) => {
+    const color = options.colors?.[p.id] ?? options.colors?.[p.material] ?? MATERIAL_COLORS[p.material] ?? 8947848;
+    const key = `${p.material}:${color}`;
+    let m = mats.get(key);
+    if (!m) {
+      const alpha = TRANSPARENT[p.material];
+      const metal = p.material === "steel" || p.material === "aluminium" || p.material === "copper" || p.material === "cast_iron";
+      m = new THREE.MeshStandardMaterial({
+        color,
+        roughness: alpha ? 0.1 : metal ? 0.45 : 0.85,
+        metalness: metal ? 0.7 : 0,
+        transparent: !!alpha,
+        opacity: alpha ?? 1,
+        depthWrite: !alpha
+      });
+      mats.set(key, m);
+    }
+    return m;
+  };
+  for (const p of spec.parts) {
+    let geo;
+    const s = p.shape;
+    if (s.kind === "box") geo = new THREE.BoxGeometry(s.size[0], s.size[1], s.size[2]);
+    else if (s.kind === "cylinder") geo = new THREE.CylinderGeometry(s.radius, s.radius, s.height, seg);
+    else geo = new THREE.SphereGeometry(s.radius, seg, Math.max(6, seg - 4));
+    const mesh = new THREE.Mesh(geo, materialFor(p));
+    mesh.name = p.id;
+    mesh.userData.destructionPart = p.id;
+    mesh.userData.destructionMaterial = p.material;
+    mesh.position.set(p.position[0], p.position[1], p.position[2]);
+    if (p.rotation) mesh.rotation.set(p.rotation[0], p.rotation[1], p.rotation[2], "XYZ");
+    mesh.castShadow = shadows && !TRANSPARENT[p.material];
+    mesh.receiveShadow = shadows;
+    root.add(mesh);
+  }
+  return root;
+}
+
 // src/explosives.ts
 import { backblastEffect, blastEffect, createExplosiveBody, tripwireSegment } from "@adatechnology/game-weapons";
 
@@ -1421,6 +523,17 @@ function createExplosives(context) {
     meshes.push(mesh);
     return mesh;
   };
+  const addModel = (query, at) => {
+    const custom = context.projectileModel?.(query);
+    if (!custom) return void 0;
+    custom.model.position.set(at[0], at[1], at[2]);
+    custom.model.traverse((child) => {
+      child.castShadow = true;
+    });
+    scene.add(custom.model);
+    meshes.push(custom.model);
+    return { mesh: custom.model, ...custom.axis ? { axis: new THREE.Vector3(custom.axis[0], custom.axis[1], custom.axis[2]).normalize() } : {} };
+  };
   const remove = (projectile) => {
     for (const extra of projectile.attached ?? []) {
       extra.removeFromParent();
@@ -1436,10 +549,11 @@ function createExplosives(context) {
   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);
+    const modeled = addModel({ weapon: context.toolId(), ...use.explosive !== void 0 ? { explosive: use.explosive } : {}, kind: isRocket ? "rocket" : isMolotov ? "molotov" : "grenade" }, use.origin);
+    const mesh = modeled?.mesh ?? addMesh(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), isMolotov ? 3897915 : isRocket ? 7041116 : 4936480, isMolotov ? 0 : 0.4, use.origin);
     projectiles.push({
       mesh,
+      ...modeled?.axis ? { axis: modeled.axis } : {},
       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(),
@@ -1490,7 +604,8 @@ function createExplosives(context) {
     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);
+    const modeled = addModel({ weapon: context.toolId(), explosive: use.explosive, kind: "charge" }, at);
+    const mesh = modeled?.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);
@@ -1614,7 +729,7 @@ function createExplosives(context) {
     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());
+      projectile.mesh.quaternion.setFromUnitVectors(projectile.axis ?? 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 } });
@@ -1736,16 +851,171 @@ var toHostEvent = (weapon, event, options = {}) => {
   }
 };
 
-// src/log.ts
-var MAX_ENTRIES = 5e3;
-var pad = (n, w = 2) => String(n).padStart(w, "0");
-var formatTime = (t) => {
-  const m = Math.floor(t / 60);
-  const s = t - m * 60;
-  return `${pad(m)}:${s.toFixed(2).padStart(5, "0")}`;
+// src/loading-view.ts
+var LOADING_CLASS = "tr-loading";
+var LOADING_CSS = [
+  '.tr-loading{position:absolute;inset:0;z-index:2147483000;display:flex;align-items:center;justify-content:center;background:rgba(16,19,26,.72);color:#e8eaee;font:15px/1.4 system-ui,-apple-system,"Segoe UI",Roboto,sans-serif;transition:opacity .25s;pointer-events:auto}',
+  ".tr-loading.tr-loading-fixed{position:fixed}",
+  ".tr-loading.tr-loading-solid{background:#10131a}",
+  ".tr-loading.tr-loading-hidden{opacity:0;pointer-events:none}",
+  ".tr-loading-card{width:min(440px,86vw);text-align:center}",
+  ".tr-loading-title{font-size:18px;font-weight:600;margin-bottom:18px}",
+  ".tr-loading-spin{display:inline-block;width:16px;height:16px;margin-right:10px;vertical-align:-2px;border:2px solid #3a3f4a;border-top-color:#ffd23f;border-radius:50%;animation:tr-loading-turn .8s linear infinite}",
+  ".tr-loading-bar{position:relative;height:8px;border-radius:4px;background:#2a2e36;overflow:hidden}",
+  ".tr-loading-bar i{display:block;height:100%;width:0;background:#ffd23f;transition:width .15s}",
+  ".tr-loading-bar.tr-loading-indeterminate i{position:absolute;width:35%;animation:tr-loading-sweep 1.1s ease-in-out infinite}",
+  ".tr-loading-step{margin-top:12px;color:#9aa3b2;min-height:1.4em}",
+  "@keyframes tr-loading-turn{to{transform:rotate(360deg)}}",
+  "@keyframes tr-loading-sweep{0%{left:-35%}100%{left:100%}}",
+  "@media (prefers-reduced-motion:reduce){.tr-loading-spin,.tr-loading-bar.tr-loading-indeterminate i{animation-duration:3s}}"
+].join("");
+var escape = (text) => text.replace(/[&<>"]/g, (c) => c === "&" ? "&amp;" : c === "<" ? "&lt;" : c === ">" ? "&gt;" : "&quot;");
+function loadingMarkup(options) {
+  const classes = [LOADING_CLASS, options.solid ? "tr-loading-solid" : "", options.fixed ? "tr-loading-fixed" : ""].filter(Boolean).join(" ");
+  const id = options.id ? ` id="${escape(options.id)}"` : "";
+  return `<div${id} class="${classes}" role="status" aria-live="polite"><div class="tr-loading-card"><div class="tr-loading-title"><span class="tr-loading-spin"></span><span class="tr-loading-label">${escape(options.title)}</span></div><div class="tr-loading-bar tr-loading-indeterminate"><i></i></div><div class="tr-loading-step">${escape(options.step ?? "")}</div></div></div>`;
+}
+
+// src/loading.ts
+var PAINT_FALLBACK_MS = 100;
+var styled = false;
+var ensureStyle = (document2) => {
+  if (styled && document2.getElementById("tr-loading-style")) return;
+  const style = document2.createElement("style");
+  style.id = "tr-loading-style";
+  style.textContent = LOADING_CSS;
+  document2.head.appendChild(style);
+  styled = true;
 };
-function createLog(options = {}) {
-  const host = globalThis.claude;
+var nextPaint = () => new Promise((resolve) => {
+  let done = false;
+  const finish = () => {
+    if (!done) {
+      done = true;
+      resolve();
+    }
+  };
+  if (typeof requestAnimationFrame === "function") requestAnimationFrame(() => setTimeout(finish, 0));
+  setTimeout(finish, PAINT_FALLBACK_MS);
+});
+function createLoading(options) {
+  const draw = options.draw !== false && typeof document !== "undefined";
+  const tasks = [];
+  const listeners = /* @__PURE__ */ new Set();
+  let element;
+  let labelNode = null;
+  let stepNode = null;
+  let barNode = null;
+  let fillNode = null;
+  let hideTimer;
+  const idlers = [];
+  const current = () => tasks[tasks.length - 1];
+  const state = () => {
+    const task = current();
+    return task ? { label: task.label, text: task.text, done: task.done, total: task.total, opaque: task.opaque, depth: tasks.length } : void 0;
+  };
+  const build = () => {
+    ensureStyle(options.container.ownerDocument);
+    const root = document.createElement("div");
+    root.className = `${LOADING_CLASS} tr-loading-hidden`;
+    root.setAttribute("role", "status");
+    root.setAttribute("aria-live", "polite");
+    root.innerHTML = '<div class="tr-loading-card"><div class="tr-loading-title"><span class="tr-loading-spin"></span><span class="tr-loading-label"></span></div><div class="tr-loading-bar tr-loading-indeterminate"><i></i></div><div class="tr-loading-step"></div></div>';
+    labelNode = root.querySelector(".tr-loading-label");
+    stepNode = root.querySelector(".tr-loading-step");
+    barNode = root.querySelector(".tr-loading-bar");
+    fillNode = root.querySelector(".tr-loading-bar i");
+    options.container.appendChild(root);
+    return root;
+  };
+  const render = () => {
+    const now = state();
+    for (const listener of listeners) listener(now);
+    if (!now) for (const wake of idlers.splice(0)) wake();
+    if (!draw) return;
+    if (!now) {
+      if (element) {
+        element.classList.add("tr-loading-hidden");
+        hideTimer = setTimeout(() => element?.style.setProperty("display", "none"), 300);
+      }
+      return;
+    }
+    if (hideTimer !== void 0) clearTimeout(hideTimer);
+    element ?? (element = build());
+    element.style.removeProperty("display");
+    element.classList.remove("tr-loading-hidden");
+    element.classList.toggle("tr-loading-solid", now.opaque);
+    if (labelNode) labelNode.textContent = now.label;
+    if (stepNode) stepNode.textContent = now.text;
+    const determinate = now.total !== void 0 && now.total > 0;
+    barNode?.classList.toggle("tr-loading-indeterminate", !determinate);
+    if (fillNode) fillNode.style.width = determinate ? `${Math.max(0, Math.min(1, now.done / now.total)) * 100}%` : "";
+  };
+  const begin = (label, taskOptions = {}) => {
+    const task = { label, text: options.working, done: 0, total: taskOptions.total, opaque: taskOptions.opaque === true, ended: false };
+    tasks.push(task);
+    render();
+    return {
+      step(text, done) {
+        if (task.ended) return;
+        if (text !== void 0) task.text = text;
+        if (done !== void 0) task.done = done;
+        render();
+      },
+      paint: nextPaint,
+      end() {
+        if (task.ended) return;
+        task.ended = true;
+        const at = tasks.indexOf(task);
+        if (at >= 0) tasks.splice(at, 1);
+        render();
+      }
+    };
+  };
+  return {
+    get active() {
+      return tasks.length > 0;
+    },
+    get element() {
+      return element;
+    },
+    state,
+    idle: () => tasks.length === 0 ? Promise.resolve() : new Promise((resolve) => idlers.push(resolve)),
+    on(listener) {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    },
+    begin,
+    async busy(label, work, taskOptions) {
+      const task = begin(label, taskOptions);
+      try {
+        await task.paint();
+        return await work(task);
+      } finally {
+        task.end();
+      }
+    },
+    dispose() {
+      if (hideTimer !== void 0) clearTimeout(hideTimer);
+      tasks.length = 0;
+      for (const wake of idlers.splice(0)) wake();
+      listeners.clear();
+      element?.remove();
+      element = void 0;
+    }
+  };
+}
+
+// src/log.ts
+var MAX_ENTRIES = 5e3;
+var pad = (n, w = 2) => String(n).padStart(w, "0");
+var formatTime = (t) => {
+  const m = Math.floor(t / 60);
+  const s = t - m * 60;
+  return `${pad(m)}:${s.toFixed(2).padStart(5, "0")}`;
+};
+function createLog(options = {}) {
+  const host = globalThis.claude;
   let downloadsP = null;
   if (host && typeof host.use === "function") {
     try {
@@ -2436,6 +1706,9 @@ function createNarrator(c) {
 var EYE = 1.7;
 var PLAYER_RADIUS = 0.3;
 var WALK = 3.4;
+var CROUCH_DROP = 0.55;
+var CROUCH_WALK = 1.7;
+var CROUCH_RATE = 9;
 var RUN = 6.2;
 var JUMP = 4.6;
 var GRAVITY = 13;
@@ -2446,15 +1719,20 @@ function createPlayer(THREE, o) {
   let pitch = 0;
   let y = 0;
   let eye = EYE;
+  let crouch = 0;
   let vy = 0;
+  let walked = 0;
+  let running = false;
   const px = { x: o.start[0], z: o.start[2] };
   let locked = false;
   const keys = /* @__PURE__ */ new Set();
+  const crouchKeys = o.crouchKeys ?? ["KeyC"];
+  const isCrouchHeld = () => crouchKeys.some((code) => keys.has(code));
   const euler = new THREE.Euler(0, 0, 0, "YXZ");
   const apply = () => {
     euler.set(pitch, yaw, 0, "YXZ");
     cam.quaternion.setFromEuler(euler);
-    cam.position.set(px.x, eye + y, px.z);
+    cam.position.set(px.x, eye + y - CROUCH_DROP * crouch, px.z);
     cam.updateMatrixWorld(true);
   };
   apply();
@@ -2481,6 +1759,20 @@ function createPlayer(THREE, o) {
   };
   const onLockChange = () => {
     locked = document.pointerLockElement === o.dom;
+    if (locked) {
+      try {
+        const nav = typeof navigator !== "undefined" ? navigator : null;
+        nav?.keyboard?.lock?.().catch(() => {
+        });
+      } catch {
+      }
+    } else {
+      try {
+        const nav = typeof navigator !== "undefined" ? navigator : null;
+        nav?.keyboard?.unlock?.();
+      } catch {
+      }
+    }
   };
   const onMouseDown = (e) => {
     o.dom.focus?.();
@@ -2550,6 +1842,10 @@ function createPlayer(THREE, o) {
   const onKeyDown = (e) => {
     if (typing(e)) return;
     if (e.code === "Space" || e.code === "Tab") e.preventDefault();
+    const isControlHeld = e.ctrlKey || e.metaKey || keys.has("ControlLeft") || keys.has("ControlRight");
+    if (isControlHeld || e.altKey && locked) {
+      if (!/^F\d+$/.test(e.code)) e.preventDefault();
+    }
     if (!e.repeat) keys.add(e.code);
     o.hooks.key(e.code, true, e);
   };
@@ -2560,6 +1856,11 @@ function createPlayer(THREE, o) {
   };
   const onContext = (e) => e.preventDefault();
   const onBlur = () => keys.clear();
+  const onBeforeUnload = (e) => {
+    if (!locked && !keys.has("ControlLeft") && !keys.has("ControlRight")) return;
+    e.preventDefault();
+    e.returnValue = "";
+  };
   o.dom.addEventListener("mousedown", onMouseDown);
   window.addEventListener("mouseup", onMouseUp);
   window.addEventListener("mousemove", onMouseMove);
@@ -2569,6 +1870,7 @@ function createPlayer(THREE, o) {
   window.addEventListener("keydown", onKeyDown);
   window.addEventListener("keyup", onKeyUp);
   window.addEventListener("blur", onBlur);
+  window.addEventListener("beforeunload", onBeforeUnload);
   return {
     get yaw() {
       return yaw;
@@ -2579,10 +1881,36 @@ function createPlayer(THREE, o) {
     get locked() {
       return locked;
     },
+    get x() {
+      return px.x;
+    },
+    get z() {
+      return px.z;
+    },
+    get feet() {
+      return y;
+    },
+    get position() {
+      return [px.x, y, px.z];
+    },
+    get speed() {
+      return walked;
+    },
+    get running() {
+      return running;
+    },
+    get crouching() {
+      return isCrouchHeld();
+    },
     keys,
     update(dt) {
-      const run = keys.has("ShiftLeft") || keys.has("ShiftRight");
-      const speed = run ? RUN : WALK;
+      const crouched = isCrouchHeld();
+      crouch += ((crouched ? 1 : 0) - crouch) * Math.min(1, dt * CROUCH_RATE);
+      if (!crouched && crouch < 1e-3) crouch = 0;
+      const run = !crouched && (keys.has("ShiftLeft") || keys.has("ShiftRight"));
+      const fromX = px.x;
+      const fromZ = px.z;
+      const speed = crouched ? CROUCH_WALK : run ? RUN : WALK;
       let f = 0;
       let r = 0;
       if (keys.has("KeyW") || keys.has("ArrowUp")) f += 1;
@@ -2598,6 +1926,8 @@ function createPlayer(THREE, o) {
         const rz = -Math.sin(yaw);
         move((fx * f + rx * r) / len * speed * dt, (fz * f + rz * r) / len * speed * dt);
       }
+      walked = dt > 0 ? Math.hypot(px.x - fromX, px.z - fromZ) / dt : 0;
+      running = run && walked > 0;
       if (y <= 0 && keys.has("Space")) vy = JUMP;
       if (y > 0 || vy > 0) {
         vy -= GRAVITY * dt;
@@ -2656,358 +1986,611 @@ function createPlayer(THREE, o) {
       window.removeEventListener("keydown", onKeyDown);
       window.removeEventListener("keyup", onKeyUp);
       window.removeEventListener("blur", onBlur);
+      window.removeEventListener("beforeunload", onBeforeUnload);
       if (document.pointerLockElement === o.dom) document.exitPointerLock?.();
     }
   };
 }
 
-// src/scenarios.ts
-import { JOINT_DEFAULTS, rotateVec, toWorld } from "@adatechnology/game-destruction";
-function makeScenarios(t, num, _locale = "en") {
-  const yn = (b) => t(b ? "yes" : "no");
-  const cn = (what, n) => t(`count.${what}.${n === 1 ? "one" : "other"}`, { n });
-  const pc = (n) => t(n === 1 ? "count.piece.one" : "count.piece.other", { n });
-  const sc = (id, run) => ({ id, name: t(`sc.${id}`), run });
-  const at = (room, itemId, x, z, y = 0, rot = 0) => room.spawn(itemId, [x, y, z], rot).objectId;
-  const look = (room, from, to) => room.look(from, to);
-  const part = (room, id, p) => room.world.part(id, p);
-  const count = (room, type, objectId) => room.log.entries({ type, objectId }).length;
-  const anyBurning = (room, id) => (room.world.state(id)?.parts ?? []).some((p) => p.burning);
-  const igniteHit = (room, id, point, temperature = 900, seconds = 3) => {
-    room.world.hit(id, { type: "fire", point, temperature, radius: 0.6, duration: seconds });
-  };
-  const COLUMN = { column_0_0_0: [-2, 1.4, -8], column_0_1_0: [2, 1.4, -8], column_0_0_1: [-2, 1.4, -4], column_0_1_1: [2, 1.4, -4] };
-  const killColumns = (room, id, ids) => {
-    for (const c of ids) room.world.hitPart(id, c, { type: "blunt", point: COLUMN[c], energy: 3e6, radius: 0.05, source: "test" });
-  };
-  const heavyCollapse = (room) => room.log.entries({ type: "collapse" }).reduce((m, e) => Math.max(m, Number(e.data?.massKg ?? 0)), 0);
-  return [
-    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);
-      const p = part(room, id, "sheet");
-      const hole = p?.holes[0];
-      expect(
-        !!hole?.through,
-        t("sc.steel_through_hole.check", { mm: num((hole?.diameter ?? 0) * 1e3, 0), through: yn(!!hole?.through), holes: p?.holes.length ?? 0, hp: `${num(p?.hp ?? 0, 0)}/${num(p?.maxHp ?? 0, 0)}` }),
-        { holes: p?.holes.length, through: hole?.through }
-      );
-    }),
-    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);
-      const p = part(room, id, "block");
-      const wall = part(room, "target_wall", "brick_1_4");
-      const through = p?.holes.some((h) => h.through) ?? true;
-      expect(
-        !through && (p?.holes.length ?? 0) + (p?.dents.length ?? 0) + (p?.cracks.length ?? 0) > 0 && (wall?.holes.length ?? 0) === 0,
-        t("sc.concrete_stops_bullet.check", { through: yn(through), dents: cn("dent", p?.dents.length ?? 0), holes: cn("hole", p?.holes.length ?? 0), cracks: cn("crack", p?.cracks.length ?? 0), hp: `${num(p?.hp ?? 0, 0)}/${num(p?.maxHp ?? 0, 0)}` }),
-        { through }
-      );
-    }),
-    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++) {
-        room.use();
-        step(1);
-      }
-      const p = part(room, id, "drum_body");
-      expect(
-        (p?.dents.length ?? 0) > 0 && p?.status !== "broken",
-        t("sc.hammer_dents_drum.check", { swings, dents: p?.dents.length ?? 0, depth: num((p?.dents[0]?.depth ?? 0) * 1e3, 1), hp: `${num(p?.hp ?? 0, 0)}/${num(p?.maxHp ?? 0, 0)}` }),
-        { swings }
-      );
-    }),
-    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++) {
-        room.use();
-        step(0.25);
-      }
-      step(0.5);
-      const fr = room.log.entries({ type: "fracture", objectId: id }).find((e) => e.part === "pane");
-      const n = Number(fr?.data?.fragments ?? 0);
-      expect(part(room, id, "pane")?.status === "broken" && shots === 1 && n >= 4, t("sc.glass_shatters.check", { shots, n }), { shots, fragments: n });
-    }),
-    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;
-      for (; shots < 4 && splinters() === 0; shots++) {
-        room.use();
-        step(1.1);
-      }
-      const holes = (room.world.state(id)?.parts ?? []).reduce((n, p) => n + p.holes.length, 0);
-      expect(splinters() > 0, t("sc.shotgun_splinters_crate.check", { shots, splinters: splinters(), holes }), { shots });
-    }),
-    sc("kick_chair_leg", ({ room, step, expect }) => {
-      const id = at(room, "chair", 0, -4);
-      const before = room.renderer.pieces().length;
-      const leg = part(room, id, "leg_1");
-      void leg;
-      let kicks = 0;
-      for (; kicks < 6 && room.renderer.pieces().length <= before && part(room, id, "leg_1"); kicks++) {
-        room.world.hitPart(id, "leg_1", { type: "blunt", point: [-0.18, 0.2, -4.18], direction: [1, 0, 0], energy: 220, radius: 0.05, source: "kick" });
-        step(0.3);
-      }
-      step(0.5);
-      const after = room.renderer.pieces().length;
-      const groups = room.world.state(id)?.groups.length ?? 1;
-      expect(
-        after > before,
-        t("sc.kick_chair_leg.check", { kicks, groups, before, after, leg: part(room, id, "leg_1") ? t("leg.still") : t("leg.gone") }),
-        { kicks, before, after }
-      );
-    }),
-    sc("kick_detaches_leg_via_tool", ({ room, step, expect }) => {
-      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);
-        const leg = toWorld(st.position, st.rotation, [-0.18, 0.2, -0.18]);
-        const side = rotateVec(st.rotation, [-0.8, 0, 0]);
-        look(room, [leg[0] + side[0], leg[1] + side[1], leg[2] + side[2]], leg);
-        room.use();
-        step(1.05);
-      }
-      step(0.5);
-      const after = room.renderer.pieces().length;
-      expect(after > before, t("sc.kick_detaches_leg_via_tool.check", { kicks, before, after, leg: part(room, id, "leg_1") ? t("leg.still") : t("leg.gone") }), { kicks, before, after });
-    }),
-    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);
-      const done = room.log.entries({ type: "detach", objectId: id })[0];
-      const elapsed = done ? done.t - t0 : 5;
-      const want = JOINT_DEFAULTS.screw.seconds;
-      const groups = room.renderer.pieces().length;
-      expect(!!done && Math.abs(elapsed - want) < 0.6 && groups >= 1, t("sc.screwdriver_shelf_board.check", { secs: num(elapsed, 1), want: num(want, 1), pieces: pc(groups) }), { elapsed, want });
-      step(0.2);
-    }),
-    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");
-      const opened = (room.world.state(id)?.joints ?? []).filter((j) => j.open).length;
-      expect(refused > 0 && opened === 0, t("sc.wrong_tool_refused.check", { refused, opened }), { refused, opened });
-    }),
-    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);
-      expect(lit, t("sc.lighter_burns_crate.lit", { lit: yn(lit) }));
-      step(500);
-      const parts = room.world.state(id)?.parts ?? [];
-      const ash = parts.filter((p) => p.status === "ashes").length;
-      const charred = Math.max(...parts.map((p) => p.char));
-      expect(ash === parts.length || ash > 0 && parts.every((p) => p.status === "ashes" || p.status === "broken" || p.char > 0.8), t("sc.lighter_burns_crate.ash", { ash, total: parts.length, char: num(charred * 100, 0) }), { ash, total: parts.length });
-    }),
-    sc("torch_melts_steel", ({ room, step, expect }) => {
-      const drum2 = at(room, "steel_drum", 0, -4);
-      const crate2 = at(room, "wooden_crate", 0.7, -4);
-      igniteHit(room, crate2, [0.7, 0.25, -3.8], 900, 2);
-      let peak = 0;
-      for (let i = 0; i < 40; i++) {
-        step(1);
-        peak = Math.max(peak, part(room, drum2, "drum_body")?.temperature ?? 0);
-      }
-      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");
-      expect((p?.melt ?? 0) > 0.02 || p?.status === "melted" || (p?.holes.length ?? 0) > 0, t("sc.torch_melts_steel.torch", { temp: num(p?.temperature ?? 0, 0), melt: num((p?.melt ?? 0) * 100, 0) }), { temperature: p?.temperature, melt: p?.melt });
-    }),
-    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);
-      const p = part(room, id, "bucket_body");
-      const drips = count(room, "drip", id);
-      expect((p?.melt ?? 0) > 0.05 || p?.status === "melted", t("sc.bucket_melts_drips.check", { melt: num((p?.melt ?? 0) * 100, 0), drips, temp: num(p?.temperature ?? 0, 0) }), { melt: p?.melt, drips });
-    }),
-    sc("gas_bottle_explodes", ({ room, step, expect }) => {
-      const bottle2 = at(room, "gas_bottle", 0, -4);
-      const crate2 = at(room, "wooden_crate", 1.3, -4);
-      const c0 = room.spawned().find((s) => s.objectId === crate2)?.root.position.clone();
-      let seconds = 0;
-      for (; seconds < 60 && count(room, "explode", bottle2) === 0; seconds++) {
-        igniteHit(room, bottle2, [0, 0.4, -3.9], 1e3, 1);
-        step(1);
-      }
-      step(1.5);
-      const c1 = room.spawned().find((s) => s.objectId === crate2)?.root.position;
-      const moved = c0 && c1 ? c0.distanceTo(c1) : 0;
-      const state = room.world.state(crate2);
-      const lost = (state?.parts ?? []).filter((p) => p.status === "broken").length + (state && state.groups.length > 1 ? 1 : 0);
-      expect(count(room, "explode", bottle2) > 0, t("sc.gas_bottle_explodes.explode", { seconds }), { seconds });
-      expect(moved > 0.3 || lost > 0, t("sc.gas_bottle_explodes.push", { moved: num(moved, 1), lost: pc(lost) }), { moved, lost });
-    }),
-    sc("bottle_drop_shatters", ({ room, step, expect }) => {
-      const id = at(room, "glass_bottle", 0, -3, 1.5);
-      step(2);
-      const p = part(room, id, "bottle_body");
-      const stain = room.fluids.stains().find((s) => s.liquid === "water");
-      expect(p?.status === "broken", t("sc.bottle_drop_shatters.check", { status: p?.status ?? "?", cracks: p?.cracks.length ?? 0, stain: yn(!!stain) }), { status: p?.status });
-    }),
-    sc("throw_chair_at_wall", ({ room, step, expect }) => {
-      const id = at(room, "chair", 0, -5.2);
-      look(room, [0, 1.7, -4.2], [0, 0.35, -5.2]);
-      room.grab();
-      look(room, [0, 1.7, -4.2], [0, 2.3, -11]);
-      step(0.3);
-      room.throwHeld(16);
-      step(2.5);
-      const hits = room.log.entries({ type: "impact" });
-      const wallDamage = room.log.entries().filter((e) => e.objectId === "target_wall" && (e.type === "dent" || e.type === "damage" || e.type === "crack" || e.type === "fracture")).length;
-      expect(hits.length > 0 && wallDamage > 0, t("sc.throw_chair_at_wall.check", { impacts: hits.length, wall: wallDamage, energy: num(Number(hits[0]?.data?.energyJ ?? 0), 0) }), { id });
-    }),
-    sc("coffee_three_sips", ({ room, step, expect }) => {
-      const id = at(room, "coffee_cup", 0, -3);
-      look(room, [0, 1, -1.8], [0, 0.05, -3]);
-      const cid = `${id}_fluid`;
-      const before = room.fluids.container(cid)?.liters ?? 0;
-      room.grab();
-      for (let i = 0; i < 3; i++) {
-        room.useItem("sip");
-        step(1.4);
-      }
-      const after = room.fluids.container(cid)?.liters ?? 0;
-      const drinks = room.log.entries().filter((e) => e.type === "fluid.drink");
-      const caffeine = drinks.some((e) => Array.isArray(e.data?.effects) && (e.data?.effects).includes("caffeine"));
-      expect(drinks.length === 3 && before - after > 0.06 && caffeine, t("sc.coffee_three_sips.check", { sips: drinks.length, before: num(before, 2), after: num(after, 2), caffeine: yn(caffeine), burn: yn(drinks.some((e) => !!e.data?.burn)) }), { before, after });
-    }),
-    sc("tilt_cup_spills", ({ room, step, expect }) => {
-      const id = at(room, "coffee_cup", 0, -3);
-      look(room, [0, 1, -1.8], [0, 0.05, -3]);
-      const cid = `${id}_fluid`;
-      const before = room.fluids.container(cid)?.liters ?? 0;
-      room.grab();
-      step(0.6);
-      room.tilt(2);
-      step(2.5);
-      const after = room.fluids.container(cid)?.liters ?? 0;
-      const stains = room.fluids.stains().filter((s) => s.liquid === "coffee").length;
-      expect(before - after > 0.03 && stains > 0, t("sc.tilt_cup_spills.check", { before: num(before, 2), after: num(after, 2), stains }), { before, after });
-    }),
-    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);
-      const streams = room.fluids.streams().filter((s) => s.cause === "leak" && s.liquid === "fuel");
-      step(5);
-      const stain = room.fluids.stains().find((s) => s.liquid === "fuel");
-      const left = room.fluids.container(`${id}_fluid`)?.liters ?? 20;
-      const hole = room.log.entries({ type: "hole", objectId: id })[0];
-      expect(streams.length > 0 && !!stain && left < 20, t("sc.jerrycan_leaks_fuel.check", { streams: streams.length, stain: yn(!!stain), left: num(left, 2), leak: hole?.data?.leak ? yn(true) : yn(false) }), { left });
-    }),
-    sc("fuel_stain_burns", ({ room, step, expect }) => {
-      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);
-      const stain = room.fluids.stains().find((s) => s.liquid === "fuel");
-      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);
-      const ignited = count(room, "stain_ignite");
-      const fireHits = (room.world.state(id)?.parts ?? []).some((p) => p.burning || p.temperature > 100) || anyBurning(room, crate2);
-      expect(ignited > 0, t("sc.fuel_stain_burns.ignite", { ignited, near: yn(fireHits) }), { ignited });
-      step(30);
-      expect(count(room, "stain_burned") > 0 || room.fluids.stains().filter((s) => s.liquid === "fuel" && s.wetness > 0.05).length === 0, t("sc.fuel_stain_burns.out", { burned: count(room, "stain_burned") }));
-    }),
-    sc("one_column_roof_stands", ({ room, step, expect }) => {
-      const id = at(room, "building_frame", 0, -6);
-      killColumns(room, id, ["column_0_0_0"]);
-      step(40);
-      const roof = part(room, id, "roof");
-      const neighbour = part(room, id, "column_0_0_1")?.stress ?? 0;
-      const heavy = Math.max(heavyCollapse(room), ...room.renderer.pieces().map((p) => p.mass));
-      expect(!!roof && roof.status !== "broken" && heavy < 2e3, t("sc.one_column_roof_stands.check", { roof: roof ? t("roof.standing") : t("roof.fell"), heavy: num(heavy, 0), stress: num(neighbour * 100, 0) }), { heavy, neighbour });
-    }),
-    sc("two_columns_roof_collapses", ({ room, step, expect }) => {
-      const id = at(room, "building_frame", 0, -6);
-      killColumns(room, id, ["column_0_0_0", "column_0_1_0"]);
-      const stress0 = room.world.part(id, "column_0_0_1")?.stress ?? 0;
-      step(40);
-      const pieces = room.renderer.pieces().filter((p) => p.mass >= 2e3);
-      const logged = heavyCollapse(room) >= 2e3;
-      const kg = pieces.reduce((m, p) => m + p.mass, 0);
-      expect(!part(room, id, "roof") && pieces.length > 0, t("sc.two_columns_roof_collapses.check", { stress: num(stress0 * 100, 0), pieces: pc(pieces.length), kg: num(kg, 0), logged: yn(logged) }), { kg, logged });
-    }),
-    sc("extinguisher_puts_out_fire", ({ room, step, expect }) => {
-      const id = at(room, "wooden_crate", 0, -4);
-      igniteHit(room, id, [0, 0.25, -3.8], 900, 4);
-      step(6);
-      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);
-      const after = anyBurning(room, id);
-      expect(!after, t("sc.extinguisher_puts_out_fire.out", { burning: yn(after), events: count(room, "extinguish", id) }), { events: count(room, "extinguish", id) });
-    })
-  ];
+// src/avatar.ts
+var DEFAULT_STRIKE_CLIPS = { hand: "punch_right", fists: "punch_right", shove: "shove_two_hands", kick: "front_kick" };
+var DEFAULT_HAND_STANCES = { fists: "fists" };
+var THIRD_PERSON_DEFAULTS = {
+  back: 3.8,
+  side: 0.9,
+  up: 1.95,
+  crouchUp: 1.4,
+  lift: 0.1,
+  margin: 0.3,
+  minDistance: 0.2,
+  probes: [0, 0.2, -0.2],
+  recover: 4
+};
+function thirdPersonPose(input, options, probe) {
+  const cy = Math.cos(input.pitch);
+  const d = [-Math.sin(input.yaw) * cy, Math.sin(input.pitch), -Math.cos(input.yaw) * cy];
+  const rx = Math.cos(input.yaw);
+  const rz = -Math.sin(input.yaw);
+  const pivot = [input.x + rx * options.side, input.feet + (input.crouch ? options.crouchUp : options.up), input.z + rz * options.side];
+  const dx = -d[0] * options.back;
+  const dy = -d[1] * options.back + options.lift;
+  const dz = -d[2] * options.back;
+  const wanted = Math.hypot(dx, dy, dz);
+  const dir = [dx / wanted, dy / wanted, dz / wanted];
+  let free = wanted;
+  for (const o of options.probes) {
+    const hit = probe([pivot[0] + rx * o, pivot[1], pivot[2] + rz * o], dir, wanted);
+    if (hit !== null) free = Math.min(free, Math.max(options.minDistance, hit - options.margin));
+  }
+  const at = (distance) => [pivot[0] + dir[0] * distance, Math.max(0.1, pivot[1] + dir[1] * distance), pivot[2] + dir[2] * distance];
+  return { position: at(free), at, pivot, direction: d, wanted, free };
 }
-var makeT = (locale) => (key, vars) => {
-  let s = resolveStrings(locale).text[key] ?? key;
-  if (vars) for (const k of Object.keys(vars)) s = s.split(`{${k}}`).join(String(vars[k]));
-  return s;
+
+// src/locale.ts
+var en = {
+  items: {},
+  groups: { furniture: "Furniture", structure: "Structure", vehicles: "Vehicles", plants: "Plants", items: "Items", containers: "Containers" },
+  text: {
+    "locale.decimal": ".",
+    yes: "yes",
+    no: "no",
+    piece: "piece",
+    coords: "x {x} \xB7 z {z}",
+    "count.piece.one": "1 piece",
+    "count.piece.other": "{n} pieces",
+    "count.joint.one": "1 joint",
+    "count.joint.other": "{n} joints",
+    "count.dent.one": "1 dent",
+    "count.dent.other": "{n} dents",
+    "count.hole.one": "1 hole",
+    "count.hole.other": "{n} holes",
+    "count.crack.one": "1 crack",
+    "count.crack.other": "{n} cracks",
+    "joint.generic": "joint",
+    "lost.broken": "broke",
+    "lost.melted": "melted away",
+    "lost.ashes": "burned to ash",
+    "tool.none": "by hand only",
+    "arena.target_wall": "Target wall",
+    "arena.table": "Table",
+    "arena.shelf": "Shelf",
+    "surface.floor": "on the floor",
+    "surface.ground": "on the floor",
+    "surface.table": "on the table",
+    "by.break": "broken loose",
+    "by.tool": "undone with a tool",
+    "by.part_lost": "the part next to it was lost",
+    "dmg.ballistic": "ballistic",
+    "dmg.blunt": "blunt",
+    "dmg.slash": "slash",
+    "dmg.explosive": "blast",
+    "dmg.fire": "fire",
+    "dmg.heat": "heat",
+    "effect.caffeine": "caffeine",
+    "effect.alcohol": "alcohol",
+    "effect.poison": "poison",
+    "effect.disgust": "disgust",
+    "ev.dent": "{where}: dent of {mm} mm, {hp}",
+    "ev.hole.through": "{where}: {mm} mm hole went through, {hp}",
+    "ev.hole.stuck": "{where}: {mm} mm hole, did not go through, {hp}",
+    "ev.dents": "{where}: {n} dents, deepest {mm} mm, {hp}",
+    "ev.holes": "{where}: {n} holes of {mm} mm, {thr} went through, {hp}",
+    "ev.leak.tail": ", leaking {liquid} at {rate} l/s",
+    "ev.leak.alone": "{where}: leaking {liquid} at {rate} l/s",
+    "ev.crack": "{where}: cracked, {rays} rays up to {cm} cm, {hp}",
+    "ev.ricochet": "{where}: bullet ricocheted, {energy} J left",
+    "ev.fracture.shatter": "{where}: shattered into {n} shards",
+    "ev.fracture.crumble": "{where}: crumbled into {n} chunks",
+    "ev.fracture.splinter": "{where}: splintered into {n} pieces",
+    "ev.fracture.tear": "{where}: torn into {n} scraps",
+    "ev.fracture.snap": "{where}: snapped into {n} pieces",
+    "ev.fracture.none": "{where}: broke into {n} pieces",
+    "ev.detach": "{obj}: {a} came off {b} ({by}); the object now has {pieces}",
+    "ev.detach.many.break": "{obj}: {joints} broke loose; the object now has {pieces}",
+    "ev.detach.many.tool": "{obj}: {joints} undone with a tool; the object now has {pieces}",
+    "ev.lost.tail": " and came loose from {joints}; the object now has {pieces}",
+    "ev.lost.alone": "{where}: {verb} and came loose from {joints}; the object now has {pieces}",
+    "ev.cracks": "{where}: cracking under the load, {n} cracks so far, longest {cm} cm, {hp}",
+    "ev.disassemble": "{obj}: undoing the {kind} between {a} and {b} with {tool}: {pct}%",
+    "ev.ignite": "{where}: caught fire at {temp} \xB0C",
+    "ev.ignite.many": "{obj}: {n} parts caught fire at {temp} \xB0C ({parts})",
+    "ev.extinguish": "{where}: fire put out",
+    "ev.extinguish.many": "{obj}: fire put out on {n} parts ({parts})",
+    "ev.burnout": "{where}: burned to ash",
+    "ev.melt": "{where}: melting, {pct}% melted away",
+    "ev.drip": "{where}: dripping molten material",
+    "ev.explode": "{where}: exploded, {energy} J within {radius} m",
+    "ev.destroyed": "{obj}: destroyed",
+    "ev.damage": "{where}: {type} damage {amount}, {hp}",
+    "ev.damage.overload": "{where}: crushed by the weight it carries, lost {amount} hp so far, {hp}",
+    "ev.stress": "{where}: overloaded at {stress}% of its capacity, carrying {load} kg",
+    "ev.collapse": "{obj}: collapsed, {pieces} fell ({mass} kg): {parts}",
+    "ev.stain_ignite": "The {liquid} stain at x {x} \xB7 z {z} caught fire and will burn for about {seconds} s",
+    "ev.stain_burned": "The burning stain burned itself out",
+    "ev.fire_dries": "Fire dried the wet stains nearby",
+    "fl.fill": "{who}: filled with {liquid} (+{liters} l)",
+    "fl.pour": "{who}: pouring {liquid} at {rate} l/s",
+    "fl.spill": "{who}: spilled {liquid} over the lip at {rate} l/s",
+    "fl.leak": "{who}: leaking {liquid} at {rate} l/s",
+    "fl.drink": "{who}: drank {liters} l, thirst +{thirst}",
+    "fl.burn": "too hot: burned the mouth",
+    "fl.empty": "{who}: empty",
+    "fl.splash": "Splash of {liquid}",
+    "fl.stain": "Stain of {liquid} {surface} at {where}",
+    "fl.stains": "{n} stains of {liquid} {surface}, the latest at {where}",
+    "fl.dried": "A stain dried up",
+    "fl.dried.mark": "A stain dried and left a mark",
+    "fl.dried.known": "The {liquid} stain {surface} at {where} dried up",
+    "fl.dried.known.mark": "The {liquid} stain {surface} at {where} dried and left a mark",
+    "fl.dried.many": "{n} {liquid} stains dried up",
+    "fl.dried.many.mark": "{n} {liquid} stains dried and left marks",
+    "fl.mix": "{who}: {from} mixed into {into}",
+    "act.anim_start": '{name}: animation "{clip}" ({seconds} s)',
+    "act.anim_event": '{name}: "{clip}" event {type}',
+    "act.anim_end": '{name}: animation "{clip}" finished',
+    "act.area_skip": 'Area item "{item}" is not loaded in this room: left out',
+    "act.module_loaded": 'Module "{name}" loaded: {items} item(s), {scenarios} scenario(s), contract checks: {result}',
+    "mod.all_ok": "all passed",
+    "mod.some_failed": "some FAILED",
+    "mod.destructible_ok": "{name}: destructible contract ok ({parts} parts, hit and state well-formed)",
+    "mod.destructible_fail": "{name}: destructible contract broken: {problems}",
+    "mod.animation_ok": '{name}: animation "{clip}" ok ({seconds} s)',
+    "mod.spec_ok": "{name}: spec ok ({parts} parts)",
+    "mod.spec_fail": "{name}: spec broken: {problems}",
+    "mod.spec_warn": "{name}: spec warning: {warning}",
+    "mod.animation_fail": '{name}: animation "{clip}" broken: {problems}',
+    "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",
+    "act.tool": "Equipped {weapon}",
+    "act.shoot.hit": "{weapon}: shot, {energy} J, hit {where} at {dist} m",
+    "act.shoot.miss": "{weapon}: shot, {energy} J, hit nothing",
+    "act.shoot.pellets": "{weapon}: shot, {n} projectiles of up to {energy} J, {hits} hit {where} at {dist} m",
+    "act.melee.hit": "{weapon}: strike, {energy} J, hit {where} at {dist} m",
+    "act.melee.miss": "{weapon}: struck the air",
+    "act.strike": "{weapon}: {clip} begins, impact in {seconds} s",
+    "act.strike.leg": "{weapon}: {clip} with the {leg} leg begins, impact in {seconds} s",
+    "leg.left": "left",
+    "leg.right": "right",
+    "act.flame.hit": "{weapon}: flame at {temp} \xB0C on {where}",
+    "act.flame.air": "{weapon}: flame, nothing in range",
+    "act.heat.hit": "{weapon}: heating {where} at {temp} \xB0C",
+    "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",
+    "act.tool.nojoint": "{weapon}: no joint near {where}",
+    "act.tool.refused": "{weapon} cannot undo the {kind} of {obj}; it needs: {need}",
+    "act.extinguish.hit": "{weapon}: foam on {what}",
+    "act.extinguish.air": "{weapon}: foam, nothing in range",
+    "act.grab": "Grabbed {name} ({kg} kg)",
+    "act.drop": "Dropped {name}",
+    "act.throw": "Threw {name} at {speed} m/s",
+    "act.landing": "{name} landed at {speed} m/s: {energy} J",
+    "act.bench_failed": "{name} failed: {error}",
+    "loading.working": "Working\u2026",
+    "loading.open_area": "Opening {area}\u2026",
+    "loading.spawn": "Building {name}\u2026",
+    "act.loosened": "{name} was heavy but free: the blast moved it",
+    "act.impact": "{name} hit {where} at {speed} m/s: {energy} J of blunt damage",
+    "act.use_item": "{name}: {use}",
+    "act.tap.on": "Tap opened",
+    "act.tap.off": "Tap closed",
+    "use.drink": "drink",
+    "use.sip": "sip",
+    "use.chug": "chug",
+    "use.pour": "pour",
+    "use.pour_out": "pour out",
+    "use.open": "open",
+    "use.close": "close",
+    "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)",
+    "hud.empty_container": "{name} is empty",
+    "hud.refused": "Wrong tool for the {kind}",
+    "hud.drop": "drop",
+    "hud.rotate": "rotate",
+    "hud.throw": "throw",
+    "hud.tilt": "tilt (hold)",
+    "hud.equip": "equip {weapon}",
+    "ui.help": "Click: look \xB7 WASD: walk \xB7 Shift: run \xB7 C: crouch \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.help.camera": "V: 1st/3rd person (Shift+V: kick)",
+    "camera.first": "1st person",
+    "camera.third": "3rd person",
+    "act.camera": "View: {mode}",
+    "ui.log": "Behaviour log",
+    "ui.filter.action": "actions",
+    "ui.filter.event": "events",
+    "ui.filter.check": "checks",
+    "ui.autoscroll": "autoscroll",
+    "log.export_cancelled": "export cancelled",
+    "ui.copy_json": "Copy JSON",
+    "ui.download_ndjson": "Download NDJSON",
+    "ui.download_txt": "Download TXT",
+    "ui.clear_log": "Clear",
+    "ui.catalog": "Catalogue",
+    "ui.clear": "Clear",
+    "ui.reset_all": "Reset all",
+    "ui.slow": "Slow motion 0.25\xD7",
+    "ui.fast": "Time \xD710",
+    "ui.tap": "Tap",
+    "ui.fullscreen": "Full screen",
+    "ui.fullscreen.hint": "Full screen opened from here keeps the whole keyboard in the game, Ctrl+W included (F11 does not)",
+    "ui.blast.shelter": "Shelter",
+    "ui.blast.fragmentHits": "Fragments",
+    "ui.blast.confinement": "Confinement",
+    "ui.blast.shelter.hint": "Blasts: walls and other parts between the blast and the target take their share",
+    "ui.blast.fragmentHits.hint": "Blasts: the pieces of what breaks fly on and hit what is behind",
+    "ui.blast.confinement.hint": "Blasts: pressure builds up in an enclosed room",
+    "metric.blast_shelter": "Blast reaching (%)",
+    "metric.blast_confinement": "Blast pressure (x)",
+    "metric.blast_fragments": "Fragment hits",
+    "act.blast_report": "Blast: {shelter}% reached the most sheltered target, pressure x{confinement}, {fragments} fragment hits, {n} targets",
+    "ui.quality": "Quality",
+    "ui.quality.low": "low",
+    "ui.quality.medium": "medium",
+    "ui.quality.high": "high",
+    "ui.equip": "Equip as a tool",
+    "ui.search_items": "Search items (all groups)",
+    "ui.search_tests": "Search tests",
+    "ui.no_results": "Nothing found",
+    "ui.objects": "{n} objects",
+    "ui.tests": "Tests",
+    "ui.run_all": "Run all",
+    "ui.running": "Running...",
+    "ui.report": "{passed} passed, {failed} failed",
+    "ui.panel": "Panels",
+    "ui.inspector": "Inspector",
+    "ui.aim_at_something": "Aim at an object",
+    "ins.material": "Material",
+    "ins.status": "Status",
+    "ins.burning": "burning",
+    "ins.hp": "Hit points",
+    "ins.temperature": "Temperature",
+    "ins.char": "Charred",
+    "ins.melt": "Melted",
+    "ins.liters": "Liquid",
+    "ins.damage": "Marks",
+    "ins.damage_counts": "{dents}, {holes}, {cracks}",
+    "ins.mass": "Mass",
+    "ins.load": "Load",
+    "ins.stress": "Stress",
+    "ins.joints": "Joints",
+    "ins.open": "open",
+    "sc.start": "Scenario: {name}",
+    "sc.pass": "Scenario passed: {name}",
+    "sc.fail": "Scenario FAILED: {name}",
+    "sc.error": "the scenario threw an error: {msg}",
+    "leg.still": "leg_1 still attached",
+    "leg.gone": "leg_1 came off",
+    "roof.standing": "roof standing",
+    "roof.fell": "roof fell"
+  }
+};
+var ptBR = {
+  items: {},
+  groups: { furniture: "M\xF3veis", structure: "Estrutura", vehicles: "Ve\xEDculos", plants: "Plantas", items: "Itens", containers: "Recipientes" },
+  text: {
+    "locale.decimal": ",",
+    yes: "sim",
+    no: "n\xE3o",
+    piece: "pe\xE7a",
+    coords: "x {x} \xB7 z {z}",
+    "count.piece.one": "1 pe\xE7a",
+    "count.piece.other": "{n} pe\xE7as",
+    "count.joint.one": "1 encaixe",
+    "count.joint.other": "{n} encaixes",
+    "count.dent.one": "1 amassado",
+    "count.dent.other": "{n} amassados",
+    "count.hole.one": "1 furo",
+    "count.hole.other": "{n} furos",
+    "count.crack.one": "1 trinca",
+    "count.crack.other": "{n} trincas",
+    "joint.generic": "junta",
+    "lost.broken": "quebrou",
+    "lost.melted": "derreteu",
+    "lost.ashes": "virou cinza",
+    "tool.none": "s\xF3 com a m\xE3o",
+    "arena.target_wall": "Parede de alvo",
+    "arena.table": "Mesa",
+    "arena.shelf": "Estante",
+    "surface.floor": "no ch\xE3o",
+    "surface.ground": "no ch\xE3o",
+    "surface.table": "na mesa",
+    "by.break": "arrebentou",
+    "by.tool": "desmontado com ferramenta",
+    "by.part_lost": "a pe\xE7a ao lado se perdeu",
+    "dmg.ballistic": "de tiro",
+    "dmg.blunt": "de impacto",
+    "dmg.slash": "de corte",
+    "dmg.explosive": "de explos\xE3o",
+    "dmg.fire": "de fogo",
+    "dmg.heat": "de calor",
+    "effect.caffeine": "cafe\xEDna",
+    "effect.alcohol": "\xE1lcool",
+    "effect.poison": "veneno",
+    "effect.disgust": "nojo",
+    "ev.dent": "{where}: amassado de {mm} mm, {hp}",
+    "ev.hole.through": "{where}: furo de {mm} mm atravessou, {hp}",
+    "ev.hole.stuck": "{where}: furo de {mm} mm n\xE3o atravessou, {hp}",
+    "ev.dents": "{where}: {n} amassados, o mais fundo com {mm} mm, {hp}",
+    "ev.holes": "{where}: {n} furos de {mm} mm, {thr} atravessaram, {hp}",
+    "ev.leak.tail": ", vazando {liquid} a {rate} l/s",
+    "ev.leak.alone": "{where}: vazando {liquid} a {rate} l/s",
+    "ev.crack": "{where}: trincou, {rays} raios de at\xE9 {cm} cm, {hp}",
+    "ev.ricochet": "{where}: a bala ricocheteou, sobraram {energy} J",
+    "ev.fracture.shatter": "{where}: estilha\xE7ou em {n} cacos",
+    "ev.fracture.crumble": "{where}: esfarelou em {n} peda\xE7os",
+    "ev.fracture.splinter": "{where}: lascou em {n} peda\xE7os",
+    "ev.fracture.tear": "{where}: rasgou em {n} retalhos",
+    "ev.fracture.snap": "{where}: partiu em {n} peda\xE7os",
+    "ev.fracture.none": "{where}: quebrou em {n} peda\xE7os",
+    "ev.detach": "{obj}: {a} soltou de {b} ({by}); o objeto agora tem {pieces}",
+    "ev.detach.many.break": "{obj}: {joints} arrebentaram; o objeto agora tem {pieces}",
+    "ev.detach.many.tool": "{obj}: {joints} soltos com ferramenta; o objeto agora tem {pieces}",
+    "ev.lost.tail": " e se soltou de {joints}; o objeto agora tem {pieces}",
+    "ev.lost.alone": "{where}: {verb} e se soltou de {joints}; o objeto agora tem {pieces}",
+    "ev.cracks": "{where}: rachando sob o peso, {n} trincas at\xE9 agora, a maior com {cm} cm, {hp}",
+    "ev.disassemble": "{obj}: soltando {kind} entre {a} e {b} com {tool}: {pct}%",
+    "ev.ignite": "{where}: pegou fogo a {temp} \xB0C",
+    "ev.ignite.many": "{obj}: {n} pe\xE7as pegaram fogo a {temp} \xB0C ({parts})",
+    "ev.extinguish": "{where}: fogo apagado",
+    "ev.extinguish.many": "{obj}: fogo apagado em {n} pe\xE7as ({parts})",
+    "ev.burnout": "{where}: virou cinza",
+    "ev.melt": "{where}: derretendo, {pct}% j\xE1 derreteu",
+    "ev.drip": "{where}: pingando material derretido",
+    "ev.explode": "{where}: explodiu, {energy} J em {radius} m",
+    "ev.destroyed": "{obj}: destru\xEDdo",
+    "ev.damage": "{where}: dano {type} de {amount}, {hp}",
+    "ev.damage.overload": "{where}: esmagado pelo peso que sustenta, perdeu {amount} hp at\xE9 agora, {hp}",
+    "ev.stress": "{where}: sobrecarregado a {stress}% da capacidade, sustentando {load} kg",
+    "ev.collapse": "{obj}: desabou, ca\xEDram {pieces} ({mass} kg): {parts}",
+    "ev.stain_ignite": "A mancha de {liquid} em x {x} \xB7 z {z} pegou fogo e vai queimar por uns {seconds} s",
+    "ev.stain_burned": "A mancha em chamas se consumiu",
+    "ev.fire_dries": "O fogo secou as manchas molhadas por perto",
+    "fl.fill": "{who}: encheu de {liquid} (+{liters} l)",
+    "fl.pour": "{who}: despejando {liquid} a {rate} l/s",
+    "fl.spill": "{who}: derramou {liquid} pela borda a {rate} l/s",
+    "fl.leak": "{who}: vazando {liquid} a {rate} l/s",
+    "fl.drink": "{who}: bebeu {liters} l, sede +{thirst}",
+    "fl.burn": "quente demais: queimou a boca",
+    "fl.empty": "{who}: vazio",
+    "fl.splash": "Respingo de {liquid}",
+    "fl.stain": "Mancha de {liquid} {surface} em {where}",
+    "fl.stains": "{n} manchas de {liquid} {surface}, a \xFAltima em {where}",
+    "fl.dried": "Uma mancha secou",
+    "fl.dried.mark": "Uma mancha secou e deixou marca",
+    "fl.dried.known": "A mancha de {liquid} {surface} em {where} secou",
+    "fl.dried.known.mark": "A mancha de {liquid} {surface} em {where} secou e deixou marca",
+    "fl.dried.many": "{n} manchas de {liquid} secaram",
+    "fl.dried.many.mark": "{n} manchas de {liquid} secaram e deixaram marca",
+    "fl.mix": "{who}: {from} misturou em {into}",
+    "act.anim_start": '{name}: anima\xE7\xE3o "{clip}" ({seconds} s)',
+    "act.anim_event": '{name}: "{clip}" evento {type}',
+    "act.anim_end": '{name}: anima\xE7\xE3o "{clip}" terminou',
+    "act.area_skip": 'Item "{item}" da \xE1rea n\xE3o est\xE1 carregado nesta sala: ficou de fora',
+    "act.module_loaded": 'M\xF3dulo "{name}" carregado: {items} item(ns), {scenarios} cen\xE1rio(s), verifica\xE7\xF5es do contrato: {result}',
+    "mod.all_ok": "todas passaram",
+    "mod.some_failed": "algumas FALHARAM",
+    "mod.destructible_ok": "{name}: contrato de destrui\xE7\xE3o ok ({parts} pe\xE7as, golpe e estado bem formados)",
+    "mod.destructible_fail": "{name}: contrato de destrui\xE7\xE3o quebrado: {problems}",
+    "mod.animation_ok": '{name}: anima\xE7\xE3o "{clip}" ok ({seconds} s)',
+    "mod.spec_ok": "{name}: spec ok ({parts} pe\xE7as)",
+    "mod.spec_fail": "{name}: spec quebrada: {problems}",
+    "mod.spec_warn": "{name}: aviso na spec: {warning}",
+    "mod.animation_fail": '{name}: anima\xE7\xE3o "{clip}" quebrada: {problems}',
+    "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",
+    "act.tool": "Equipou {weapon}",
+    "act.shoot.hit": "{weapon}: disparo, {energy} J, acertou {where} a {dist} m",
+    "act.shoot.miss": "{weapon}: disparo, {energy} J, n\xE3o acertou nada",
+    "act.shoot.pellets": "{weapon}: disparo, {n} proj\xE9teis de at\xE9 {energy} J, {hits} acertaram {where} a {dist} m",
+    "act.melee.hit": "{weapon}: golpe, {energy} J, acertou {where} a {dist} m",
+    "act.melee.miss": "{weapon}: golpe no ar",
+    "act.strike": "{weapon}: {clip} come\xE7a, impacto em {seconds} s",
+    "act.strike.leg": "{weapon}: {clip} com a perna {leg} come\xE7a, impacto em {seconds} s",
+    "leg.left": "esquerda",
+    "leg.right": "direita",
+    "act.flame.hit": "{weapon}: chama a {temp} \xB0C em {where}",
+    "act.flame.air": "{weapon}: chama, nada ao alcance",
+    "act.heat.hit": "{weapon}: esquentando {where} a {temp} \xB0C",
+    "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",
+    "act.tool.nojoint": "{weapon}: nenhuma junta perto de {where}",
+    "act.tool.refused": "{weapon} n\xE3o solta {kind} de {obj}; precisa de: {need}",
+    "act.extinguish.hit": "{weapon}: espuma em {what}",
+    "act.extinguish.air": "{weapon}: espuma, nada ao alcance",
+    "act.grab": "Pegou {name} ({kg} kg)",
+    "act.drop": "Soltou {name}",
+    "act.throw": "Arremessou {name} a {speed} m/s",
+    "act.landing": "{name} caiu a {speed} m/s: {energy} J",
+    "act.bench_failed": "{name} falhou: {error}",
+    "loading.working": "Trabalhando\u2026",
+    "loading.open_area": "Abrindo {area}\u2026",
+    "loading.spawn": "Montando {name}\u2026",
+    "act.loosened": "{name} \xE9 pesado mas estava solto: a explos\xE3o o moveu",
+    "act.impact": "{name} bateu em {where} a {speed} m/s: {energy} J de dano de impacto",
+    "act.use_item": "{name}: {use}",
+    "act.tap.on": "Abriu a torneira",
+    "act.tap.off": "Fechou a torneira",
+    "use.drink": "beber",
+    "use.sip": "golinho",
+    "use.chug": "virar",
+    "use.pour": "despejar",
+    "use.pour_out": "esvaziar",
+    "use.open": "abrir",
+    "use.close": "fechar",
+    "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)",
+    "hud.empty_container": "{name} est\xE1 vazio",
+    "hud.refused": "Ferramenta errada para {kind}",
+    "hud.drop": "soltar",
+    "hud.rotate": "girar",
+    "hud.throw": "arremessar",
+    "hud.tilt": "inclinar (segurar)",
+    "hud.equip": "equipar {weapon}",
+    "ui.help": "Clique: olhar \xB7 WASD: andar \xB7 Shift: correr \xB7 C: agachar \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.help.camera": "V: 1\xAA/3\xAA pessoa (Shift+V: chute)",
+    "camera.first": "1\xAA pessoa",
+    "camera.third": "3\xAA pessoa",
+    "act.camera": "C\xE2mera: {mode}",
+    "ui.log": "Registro de comportamento",
+    "ui.filter.action": "a\xE7\xF5es",
+    "ui.filter.event": "eventos",
+    "ui.filter.check": "testes",
+    "ui.autoscroll": "rolar sozinho",
+    "log.export_cancelled": "exporta\xE7\xE3o cancelada",
+    "ui.copy_json": "Copiar JSON",
+    "ui.download_ndjson": "Baixar NDJSON",
+    "ui.download_txt": "Baixar TXT",
+    "ui.clear_log": "Limpar",
+    "ui.catalog": "Cat\xE1logo",
+    "ui.clear": "Limpar",
+    "ui.reset_all": "Consertar tudo",
+    "ui.slow": "C\xE2mera lenta 0,25\xD7",
+    "ui.fast": "Tempo \xD710",
+    "ui.tap": "Torneira",
+    "ui.fullscreen": "Tela cheia",
+    "ui.fullscreen.hint": "A tela cheia aberta por aqui segura o teclado todo no jogo, inclusive Ctrl+W (o F11 n\xE3o)",
+    "ui.blast.shelter": "Abrigo",
+    "ui.blast.fragmentHits": "Estilha\xE7os",
+    "ui.blast.confinement": "Confinamento",
+    "ui.blast.shelter.hint": "Explos\xF5es: paredes e outras partes entre a explos\xE3o e o alvo ficam com a sua parte",
+    "ui.blast.fragmentHits.hint": "Explos\xF5es: os peda\xE7os do que quebra voam e acertam o que est\xE1 atr\xE1s",
+    "ui.blast.confinement.hint": "Explos\xF5es: a press\xE3o sobe num ambiente fechado",
+    "metric.blast_shelter": "Explos\xE3o que chegou (%)",
+    "metric.blast_confinement": "Press\xE3o da explos\xE3o (x)",
+    "metric.blast_fragments": "Estilha\xE7os que acertaram",
+    "act.blast_report": "Explos\xE3o: {shelter}% chegou ao alvo mais abrigado, press\xE3o x{confinement}, {fragments} estilha\xE7os acertaram, {n} alvos",
+    "ui.quality": "Qualidade",
+    "ui.quality.low": "baixa",
+    "ui.quality.medium": "m\xE9dia",
+    "ui.quality.high": "alta",
+    "ui.equip": "Equipar como ferramenta",
+    "ui.search_items": "Buscar item (todas as abas)",
+    "ui.search_tests": "Buscar teste",
+    "ui.no_results": "Nada encontrado",
+    "ui.objects": "{n} objetos",
+    "ui.tests": "Testes",
+    "ui.run_all": "Rodar todos",
+    "ui.running": "Rodando...",
+    "ui.report": "{passed} passaram, {failed} falharam",
+    "ui.panel": "Pain\xE9is",
+    "ui.inspector": "Inspetor",
+    "ui.aim_at_something": "Mire em um objeto",
+    "ins.material": "Material",
+    "ins.status": "Estado",
+    "ins.burning": "em chamas",
+    "ins.hp": "Pontos de vida",
+    "ins.temperature": "Temperatura",
+    "ins.char": "Carbonizado",
+    "ins.melt": "Derretido",
+    "ins.liters": "L\xEDquido",
+    "ins.damage": "Marcas",
+    "ins.damage_counts": "{dents}, {holes}, {cracks}",
+    "ins.mass": "Massa",
+    "ins.load": "Carga",
+    "ins.stress": "Tens\xE3o",
+    "ins.joints": "Juntas",
+    "ins.open": "aberta",
+    "sc.start": "Cen\xE1rio: {name}",
+    "sc.pass": "Cen\xE1rio passou: {name}",
+    "sc.fail": "Cen\xE1rio FALHOU: {name}",
+    "sc.error": "o cen\xE1rio lan\xE7ou um erro: {msg}",
+    "leg.still": "leg_1 continua presa",
+    "leg.gone": "leg_1 soltou",
+    "roof.standing": "laje de p\xE9",
+    "roof.fell": "laje caiu"
+  }
 };
-function scenariosFor(locale = "en") {
-  const pt = locale.toLowerCase().startsWith("pt");
-  return makeScenarios(makeT(locale), (n, d = 1) => pt ? (Math.round(n * 10 ** d) / 10 ** d).toFixed(d).replace(".", ",") : (Math.round(n * 10 ** d) / 10 ** d).toFixed(d), locale);
-}
-var SCENARIOS = scenariosFor("en");
+var locales = { en, "pt-BR": ptBR };
+var resolveStrings = (locale) => locales[locale ?? "en"] ?? locales.en;
 
 // src/bench-panel.ts
 var SEGMENTED_MAX = 4;
@@ -3382,6 +2965,19 @@ var thumb = (thumbnail, credit) => {
   e.style.setProperty("--tr-thumb", `url("${thumbSource(thumbnail)}")`);
   return e;
 };
+async function toggleFullscreen() {
+  const keyboard = navigator.keyboard;
+  try {
+    if (document.fullscreenElement) {
+      keyboard?.unlock?.();
+      await document.exitFullscreen();
+      return;
+    }
+    await document.documentElement.requestFullscreen();
+    await keyboard?.lock?.();
+  } catch {
+  }
+}
 function createUi(o) {
   const { t } = o;
   const style = mk2("style");
@@ -3593,6 +3189,8 @@ function createUi(o) {
     o.onFast(fast);
   });
   const tapBtn = ctl(t("ui.tap"), () => o.onTap());
+  const fullscreenBtn = ctl(t("ui.fullscreen"), () => void toggleFullscreen());
+  fullscreenBtn.title = t("ui.fullscreen.hint");
   const blastBtns = ["shelter", "fragmentHits", "confinement"].map((key) => ({ key, b: ctl(t(`ui.blast.${key}`), () => o.onBlast(key)) }));
   for (const { key, b } of blastBtns) b.title = t(`ui.blast.${key}.hint`);
   const qSel = mk2("select");
@@ -3758,6 +3356,9 @@ function createUi(o) {
       toolBox.textContent = "";
       toolBox.append(document.createTextNode(s.toolName));
       if (s.ammo) toolBox.append(mk2("small", void 0, s.ammo));
+      if (s.camera) toolBox.append(mk2("small", void 0, t(`camera.${s.camera}`)));
+      const helpText = s.camera ? `${t("ui.help")} \xB7 ${t("ui.help.camera")}` : t("ui.help");
+      if (help.textContent !== helpText) help.textContent = helpText;
       if (s.status) status.textContent = s.status;
       else if (!toastTimer) status.textContent = "";
       if (s.progress) {
@@ -3847,6 +3448,10 @@ function createUi(o) {
 // src/room.ts
 var FIXED_DT = 1 / 60;
 var METRICS_INTERVAL_S = 0.25;
+var CARRY_NEAR = 0.62;
+var CARRY_PALM = 0.012;
+var CARRY_GRIP = 0.45;
+var MAX_STRIDE_SPEED = 10;
 var v3 = (v) => [v.x, v.y, v.z];
 var dist3 = (a, b) => Math.hypot(a[0] - b[0], a[1] - b[1], a[2] - b[2]);
 function createTestRoom(options) {
@@ -3860,6 +3465,7 @@ function createTestRoom(options) {
     if (vars) for (const k of Object.keys(vars)) s = s.split(`{${k}}`).join(String(vars[k]));
     return s;
   };
+  const loading = createLoading({ container: options.container, draw: options.ui !== false, working: t("loading.working") });
   const num = (n, digits = 1) => {
     const s = (Math.round(n * 10 ** digits) / 10 ** digits).toFixed(digits);
     return locale.toLowerCase().startsWith("pt") ? s.replace(".", ",") : s;
@@ -3895,13 +3501,13 @@ function createTestRoom(options) {
   const onResize = () => resize();
   window.addEventListener("resize", onResize);
   const arenaSize = options.arenaSize ?? 14;
-  const arena = createArena(THREE, arenaSize, scene);
+  const arena = createArena(THREE, arenaSize, scene, options.scenery, options.tap);
   scene.add(arena.group);
   const ownWorld = !options.world;
-  const world = options.world ?? createDestruction({ seed: 1, ...options.worldOptions, materials: [...DEMO_MATERIALS, ...options.worldOptions?.materials ?? []] });
+  const world = options.world ?? createDestruction({ seed: 1, ...options.worldOptions, materials: [...options.worldOptions?.materials ?? []] });
   const pristineWorld = ownWorld ? world.serialize() : null;
-  const tableOk = () => {
-    const p = world.part(arena.table.id, arena.table.topPart);
+  const topOk = (t2) => {
+    const p = world.part(t2.id, t2.topPart);
     return !!p && p.status !== "broken" && p.status !== "melted" && p.status !== "ashes";
   };
   const restingTops = [];
@@ -3910,7 +3516,12 @@ function createTestRoom(options) {
     for (const c of restingTops) if (x > c.minX && x < c.maxX && z > c.minZ && z < c.maxZ && world.has(c.objectId)) top = Math.max(top, c.top);
     return top;
   };
-  const groundAt = (x, z) => Math.max(x > arena.table.minX && x < arena.table.maxX && z > arena.table.minZ && z < arena.table.maxZ && tableOk() ? arena.table.top : 0, restingTopAt(x, z));
+  const sceneryTopAt = (x, z) => {
+    let top = 0;
+    for (const t2 of arena.tops) if (t2.top > top && x > t2.minX && x < t2.maxX && z > t2.minZ && z < t2.maxZ && topOk(t2)) top = t2.top;
+    return top;
+  };
+  const groundAt = (x, z) => Math.max(sceneryTopAt(x, z), restingTopAt(x, z));
   const ownFluids = !options.fluids;
   const fluids = options.fluids ?? createFluids({ seed: 1, locale, liquids: options.liquids, groundAt });
   const pristineFluids = ownFluids ? fluids.serialize() : null;
@@ -3958,6 +3569,19 @@ function createTestRoom(options) {
     groundAt,
     pointScale,
     onSound: playSound,
+    ...options.blastShove ? { blastShove: options.blastShove } : {},
+    // a blast moves what is heavy but not nailed down: the renderer makes it a piece the moment the shove reaches it
+    shoveable: (objectId) => {
+      const e = entries.get(objectId);
+      return e?.free === true && !e.piece;
+    },
+    onLoosened: (objectId, piece) => {
+      const e = entries.get(objectId);
+      if (!e) return;
+      e.piece = piece;
+      rendererPieces.set(objectId, piece);
+      action("loosened", t("act.loosened", { name: e.name }), { objectId, itemId: e.so.itemId });
+    },
     onPiece: (piece) => {
       rendererPieces.set(piece.objectId, piece);
       loose.push(piece);
@@ -4012,7 +3636,6 @@ function createTestRoom(options) {
   };
   let tool = toolState(toolId);
   const catalogMap = /* @__PURE__ */ new Map();
-  for (const i of demoItems(locale)) catalogMap.set(i.id, i);
   for (const i of options.catalog) catalogMap.set(i.id, i);
   const catalog = [...options.catalog];
   const entryOf = (objectId) => entries.get(objectId) ?? splitOf.get(objectId);
@@ -4052,7 +3675,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 };
+  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 fire = (type, data) => {
     for (const fn of listeners[type] ?? []) fn(data);
   };
@@ -4121,6 +3744,7 @@ function createTestRoom(options) {
     blockers,
     limit: arenaSize,
     start: arena.playerStart,
+    crouchKeys: options.crouch?.keys,
     hooks: {
       primaryDown: () => {
         useHeld = true;
@@ -4179,19 +3803,38 @@ function createTestRoom(options) {
   };
   const addArena = () => {
     for (const o of arena.objects) {
-      const root = buildFromSpec(THREE, o.spec, { colors: o.colors });
+      const root = o.build ? o.build(THREE) : buildFromSpec(THREE, o.spec, { colors: o.colors });
       root.position.set(o.position[0], o.position[1], o.position[2]);
+      root.rotation.y = o.rotationY;
       scene.add(root);
       root.updateMatrixWorld(true);
-      world.add(structuredCloneSpec(o.spec), { id: o.id, position: o.position });
-      registerEntry(o.id, o.id, root, o.spec, S.text[`arena.${o.id}`] ?? o.id, void 0, void 0, true, false);
+      world.add(structuredCloneSpec(o.spec), { id: o.id, position: o.position, ...o.rotationY ? { rotation: [0, Math.sin(o.rotationY / 2), 0, Math.cos(o.rotationY / 2)] } : {} });
+      registerEntry(o.id, o.id, root, o.spec, o.label ?? S.text[`arena.${o.id}`] ?? o.id, void 0, void 0, true, false);
     }
   };
   addArena();
+  const wrapped = /* @__PURE__ */ new WeakMap();
+  const letGo = (root) => {
+    const inner = wrapped.get(root);
+    if (!inner) return;
+    inner.removeFromParent();
+    wrapped.delete(root);
+  };
+  const buildRoot = (item) => {
+    const built = item.build(THREE);
+    if (item.impl || Math.abs(built.scale.x - 1) < 1e-6 && Math.abs(built.scale.y - 1) < 1e-6 && Math.abs(built.scale.z - 1) < 1e-6) return built;
+    const holder = new THREE.Group();
+    holder.name = built.name;
+    holder.userData = built.userData;
+    holder.add(built);
+    wrapped.set(holder, built);
+    Object.defineProperty(holder, "visible", { get: () => built.visible, set: (v) => void (built.visible = v), configurable: true });
+    return holder;
+  };
   const spawn = (itemId, position, rotationY) => {
     const item = catalogMap.get(itemId);
     if (!item) throw new Error(`game-test-room: unknown item "${itemId}"`);
-    const root = item.build(THREE);
+    const root = buildRoot(item);
     let pos;
     if (position) pos = [position[0], position[1], position[2]];
     else {
@@ -4234,6 +3877,7 @@ function createTestRoom(options) {
     if (own) world.register(own, { id: objectId, position: pos, rotation: [q.x, q.y, q.z, q.w] });
     else world.add(spec, { id: objectId, position: pos, rotation: [q.x, q.y, q.z, q.w] });
     const e = registerEntry(objectId, item.id, root, spec, item.name, parts, item, false, movable);
+    if (!own && !movable && item.movable === void 0) e.free = true;
     action("spawn", t("act.spawn", { name: item.name, x: num(pos[0], 1), z: num(pos[2], 1) }), { objectId, itemId: item.id, data: { position: pos, movable, massKg: Math.round(massOfObject(objectId) * 10) / 10 } });
     fire("spawn", e.so);
     return e.so;
@@ -4262,6 +3906,7 @@ function createTestRoom(options) {
     }
     if (world.has(id)) world.remove(id);
     e.so.root.removeFromParent();
+    letGo(e.so.root);
     entries.delete(id);
     rendererPieces.delete(id);
     specs.delete(id);
@@ -4336,6 +3981,7 @@ function createTestRoom(options) {
       for (const s of [...arena.surfaces, ...options.surfaces ?? []]) fluids.addSurface(s);
     }
     pending = [];
+    strikes = [];
     rng = 12345;
     counter = 0;
     slot = 0;
@@ -4348,6 +3994,108 @@ function createTestRoom(options) {
   };
   const aimO = [0, 0, 0];
   const aimD = [0, 0, -1];
+  const third = { ...THIRD_PERSON_DEFAULTS, ...options.thirdPerson };
+  let avatar = null;
+  let cameraMode = options.cameraMode ?? "first";
+  let crouchForced = false;
+  const avatarState = { speed: 0, running: false, crouch: false, down: false, armed: false, pitch: 0 };
+  let feetPrev = null;
+  let armedForced = null;
+  let camDistance = Infinity;
+  const tmpHand = new THREE.Vector3();
+  const thirdPose = (dt) => {
+    const pose = thirdPersonPose(
+      { x: player.x, z: player.z, feet: player.feet, yaw: player.yaw, pitch: player.pitch, crouch: avatarState.crouch },
+      third,
+      (o, d, max) => withoutHeld(() => world.raycast(o, d, max))?.distance ?? null
+    );
+    camDistance = pose.free <= camDistance ? pose.free : dt > 0 ? camDistance + (pose.free - camDistance) * (1 - Math.exp(-dt * third.recover)) : camDistance;
+    return { ...pose, position: pose.at(camDistance), free: camDistance };
+  };
+  const thirdActive = () => cameraMode === "third" && avatar !== null;
+  const syncAvatarVisible = () => {
+    if (!avatar) return;
+    avatar.root.visible = cameraMode === "third";
+    if (avatar.firstPerson) avatar.firstPerson.root.visible = cameraMode === "first";
+  };
+  const setCameraMode = (mode) => {
+    if (mode !== "first" && mode !== "third") return;
+    if (mode === cameraMode) return;
+    cameraMode = mode;
+    camDistance = Infinity;
+    syncAvatarVisible();
+    action("camera", t("act.camera", { mode: t(`camera.${mode}`) }), { data: { mode, avatar: avatar !== null } });
+    fire("camera", mode);
+  };
+  const setAvatar = (next) => {
+    if (avatar === next) return;
+    avatar?.root.removeFromParent();
+    avatar?.firstPerson?.root.removeFromParent();
+    avatar = next;
+    feetPrev = null;
+    if (avatar) {
+      scene.add(avatar.root);
+      if (avatar.firstPerson) scene.add(avatar.firstPerson.root);
+      syncAvatarVisible();
+      stepAvatar(0);
+    }
+    ui?.hud(hudState());
+  };
+  const stepAvatar = (dt) => {
+    if (!avatar) return;
+    const x = player.x;
+    const z = player.z;
+    if (dt > 0 && feetPrev) {
+      const raw = Math.hypot(x - feetPrev[0], z - feetPrev[1]) / dt;
+      avatarState.speed = raw > MAX_STRIDE_SPEED ? 0 : avatarState.speed + (raw - avatarState.speed) * (1 - Math.exp(-dt * 15));
+      if (avatarState.speed < 0.02) avatarState.speed = 0;
+    }
+    feetPrev = [x, z];
+    avatarState.running = !player.crouching && (player.keys.has("ShiftLeft") || player.keys.has("ShiftRight"));
+    avatarState.crouch = crouchForced || player.crouching;
+    avatarState.armed = armedForced ?? tool.def.action.kind === "firearm";
+    avatarState.pitch = player.pitch;
+    avatarState.holding = heldPiece !== null;
+    avatarState.itemUse = useItemPlayer ? { id: useItemName, ...useItemPlayer.pose() } : heldPiece && heldTilt > 0.01 ? { id: "tilt", position: [0.2, -0.1, -0.38], rotation: [-heldTilt, 0, 0] } : null;
+    avatar.root.position.set(x, player.feet, z);
+    avatar.root.rotation.set(0, player.yaw + Math.PI, 0);
+    avatar.update(dt, avatarState);
+    avatar.root.updateMatrixWorld(true);
+  };
+  let handSource = null;
+  let carriedHand = null;
+  let debugView = null;
+  let lastHand = { stance: "relaxed", triggerFinger: null, targets: null };
+  const strikeClips = options.strikeClips ?? DEFAULT_STRIKE_CLIPS;
+  const handStances = options.handStances ?? DEFAULT_HAND_STANCES;
+  const stepFirstPerson = (dt) => {
+    const arms = avatar?.firstPerson;
+    if (!arms) return;
+    const targets = handSource?.() ?? carriedHand;
+    const state = {
+      camera,
+      targets,
+      stance: handStances[toolId] ?? (targets ? "hold" : "relaxed"),
+      speed: avatarState.speed,
+      running: avatarState.running,
+      crouch: avatarState.crouch,
+      contact: (origin, direction, maxDistance) => rayWorld(origin, direction, maxDistance)?.distance ?? null,
+      triggerFinger: targets?.fingers?.index ?? null
+    };
+    lastHand = { stance: state.stance, triggerFinger: state.triggerFinger, targets };
+    arms.update(dt, state);
+  };
+  const applyThirdView = () => {
+    if (!thirdActive()) return () => void 0;
+    const home = camera.position.clone();
+    const pose = thirdPose(0);
+    camera.position.set(pose.position[0], pose.position[1], pose.position[2]);
+    camera.updateMatrixWorld(true);
+    return () => {
+      camera.position.copy(home);
+      camera.updateMatrixWorld(true);
+    };
+  };
   const aim = () => {
     camera.updateMatrixWorld(true);
     camera.getWorldPosition(tmpV);
@@ -4358,6 +4106,21 @@ function createTestRoom(options) {
     aimD[0] = tmpV2.x;
     aimD[1] = tmpV2.y;
     aimD[2] = tmpV2.z;
+    if (thirdActive()) {
+      const pose = thirdPose(0);
+      const reach = 80;
+      const hit = withoutHeld(() => world.raycast(pose.position, pose.direction, reach));
+      const dist = hit ? hit.distance : reach;
+      const tx = pose.position[0] + pose.direction[0] * dist - aimO[0];
+      const ty = pose.position[1] + pose.direction[1] * dist - aimO[1];
+      const tz = pose.position[2] + pose.direction[2] * dist - aimO[2];
+      const len = Math.hypot(tx, ty, tz);
+      if (len > 0.5 && (tx * pose.direction[0] + ty * pose.direction[1] + tz * pose.direction[2]) / len > 0.5) {
+        aimD[0] = tx / len;
+        aimD[1] = ty / len;
+        aimD[2] = tz / len;
+      }
+    }
   };
   const FAR = [0, 0, 0, 1];
   const withoutHeld = (fn) => {
@@ -4511,7 +4274,7 @@ function createTestRoom(options) {
     withoutHeld(() => {
       for (const s of shots) {
         energy = Math.max(energy, s.energy);
-        const results = world.shoot(s.origin, s.direction, s.energy, s.caliber, "player");
+        const results = world.shoot(s.origin, s.direction, s.energy, s.caliber, "player", shotExtras(s));
         const r0 = results.find((r) => r.part && r.point);
         let end = [s.origin[0] + s.direction[0] * 40, s.origin[1] + s.direction[1] * 40, s.origin[2] + s.direction[2] * 40];
         if (r0?.point && r0.part) {
@@ -4569,7 +4332,7 @@ function createTestRoom(options) {
         const r = world.raycast(u.origin, d, u.range);
         if (!r) continue;
         if (!target) target = r;
-        world.hit(r.object, { type, point: r.point, direction: d, temperature: u.temperature, radius: Math.min(u.radius, 0.3), duration: u.duration, source: "player" });
+        world.hit(r.object, { ...useToHit(u, r.point, r.normal), type, direction: d, source: "player" });
         if (type === "fire") igniteNear(r.point, 0.25);
         else renderer.emit("sparks", r.point, r.normal, 2, 4);
       }
@@ -4603,7 +4366,7 @@ function createTestRoom(options) {
       action("melee", t("act.melee.miss", { weapon: w }), { data: { weapon: id } });
       return;
     }
-    world.hitPart(r.object, r.part, { type: u.damage, point: r.point, direction: u.direction, energy: u.energy, radius: u.radius, source: "player" });
+    world.hitPart(r.object, r.part, { ...useToHit(u, r.point, r.normal), source: "player" });
     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,
@@ -4612,6 +4375,35 @@ function createTestRoom(options) {
       data: { weapon: id, damage: u.damage, energyJ: u.energy, distanceM: Math.round(r.distance * 100) / 100 }
     });
   };
+  let strikes = [];
+  const kickLeg = options.kickLeg ?? "alternate";
+  let nextLeg = "right";
+  const strikeUse = (u, id = toolId) => {
+    const clip = strikeClips[id];
+    const leg = id === "kick" ? kickLeg === "alternate" ? nextLeg : kickLeg : void 0;
+    const seconds = clip === void 0 ? null : avatar?.strike?.(clip, leg ? { leg } : void 0) ?? null;
+    if (leg && seconds !== null && kickLeg === "alternate") nextLeg = leg === "right" ? "left" : "right";
+    if (clip === void 0 || seconds === null) {
+      meleeUse(u, id);
+      return;
+    }
+    action("strike", t(leg ? "act.strike.leg" : "act.strike", { weapon: toolName(id), clip, seconds: num(seconds, 2), leg: leg ? t(`leg.${leg}`) : "" }), { data: { weapon: id, clip, impactIn: seconds, ...leg ? { leg } : {} } });
+    strikes.push({
+      key: id,
+      remaining: seconds,
+      land: () => {
+        aim();
+        meleeUse({ ...u, origin: [aimO[0], aimO[1], aimO[2]], direction: [aimD[0], aimD[1], aimD[2]] }, id);
+      }
+    });
+  };
+  const stepStrikes = (dt) => {
+    if (strikes.length === 0) return;
+    for (const strike of strikes) strike.remaining -= dt;
+    const landed = strikes.filter((strike) => strike.remaining <= 0);
+    strikes = strikes.filter((strike) => strike.remaining > 0);
+    for (const strike of landed) strike.land();
+  };
   const toolWork = (u, dt) => {
     const w = toolName();
     const r = rayWorld(u.origin, u.direction, u.reach);
@@ -4630,7 +4422,7 @@ function createTestRoom(options) {
     const p = world.disassemble(r.object, j.id, tool_, dt);
     const kind = dStrings.jointKinds[j.kind] ?? j.kind;
     if (p < 0) {
-      const need = JOINT_DEFAULTS2[j.kind].tools.map((k) => dStrings.toolKinds[k] ?? k).join(", ") || t("tool.none");
+      const need = JOINT_DEFAULTS[j.kind].tools.map((k) => dStrings.toolKinds[k] ?? k).join(", ") || t("tool.none");
       progress = { label: t("hud.refused", { kind }), value: 0, at: simTime };
       log.coalesce(
         `refuse:${r.object}:${j.id}:${toolId}`,
@@ -4640,7 +4432,7 @@ function createTestRoom(options) {
           text: t("act.tool.refused", { weapon: w, kind, obj: nameOf(r.object), need }),
           objectId: r.object,
           itemId: entryOf(r.object)?.so.itemId,
-          data: { weapon: toolId, joint: j.id, kind: j.kind, needs: JOINT_DEFAULTS2[j.kind].tools }
+          data: { weapon: toolId, joint: j.id, kind: j.kind, needs: JOINT_DEFAULTS[j.kind].tools }
         },
         2
       );
@@ -4714,12 +4506,18 @@ function createTestRoom(options) {
     action,
     emitHost,
     startFire,
-    say
+    say,
+    projectileModel: options.projectileModel
   });
   const useTool = (dt, held) => {
     aim();
     const cat = tool.def.category;
-    if (cat === "hand") return;
+    if (cat === "hand") {
+      if (strikes.some((strike) => strike.key === "hand" || strike.key === "fists")) return;
+      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;
+    }
+    if (strikes.some((strike) => strike.key === toolId)) 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") {
@@ -4741,7 +4539,7 @@ function createTestRoom(options) {
     for (const u of res.uses) {
       switch (u.kind) {
         case "melee":
-          meleeUse(u);
+          strikeUse(u);
           break;
         case "flame":
           heatRays(u, "fire");
@@ -4780,11 +4578,11 @@ function createTestRoom(options) {
     if (res) applyUses(res, 0);
   };
   const kick = () => {
-    if (!arsenal.weapons.has("kick")) return;
+    if (!arsenal.weapons.has("kick") || strikes.some((strike) => strike.key === "kick")) return;
     aim();
     const res = toolState("kick").trigger([aimO[0], aimO[1], aimO[2]], [aimD[0], aimD[1], aimD[2]], 0, false, "player");
     if (res.status !== "ok") return;
-    for (const u of res.uses) if (u.kind === "melee") meleeUse(u, "kick");
+    for (const u of res.uses) if (u.kind === "melee") strikeUse(u, "kick");
   };
   const setTool = (id) => {
     if (!arsenal.weapons.has(id)) throw new Error(`game-test-room: unknown weapon "${id}"`);
@@ -4811,6 +4609,8 @@ function createTestRoom(options) {
   let heldTilt = 0;
   let tiltKey = 0;
   const heldLocal = new THREE.Vector3();
+  const heldSize = new THREE.Vector3(0.2, 0.2, 0.2);
+  let heldRadius = 0.2;
   const heldVel = [0, 0, 0];
   let useItemPlayer = null;
   let useItemName = "";
@@ -4855,11 +4655,15 @@ function createTestRoom(options) {
     heldName = nameOf(r.object);
     piece.held = true;
     piece.sleeping = false;
+    const savedQ = piece.root.quaternion.clone();
+    piece.root.quaternion.identity();
+    piece.root.updateMatrixWorld(true);
     const box2 = new THREE.Box3().setFromObject(piece.root);
-    const c = box2.getCenter(new THREE.Vector3());
+    box2.getCenter(heldLocal).sub(piece.root.position);
+    box2.getSize(heldSize);
+    piece.root.quaternion.copy(savedQ);
     piece.root.updateMatrixWorld(true);
-    heldLocal.copy(c).sub(piece.root.position);
-    heldLocal.applyQuaternion(piece.root.quaternion.clone().invert());
+    heldRadius = heldSize.length() / 3;
     heldYaw = 0;
     heldTilt = 0;
     heldVel[0] = heldVel[1] = heldVel[2] = 0;
@@ -4880,24 +4684,93 @@ function createTestRoom(options) {
     fire("throw", { objectId: id, speed });
     return true;
   };
+  const carriedTargets = (root, gripQ) => {
+    const width2 = Math.max(heldSize.x, heldSize.z);
+    const sideGrip = heldSize.y > width2 * 1.04 && width2 <= 0.22;
+    if (sideGrip) {
+      const center2 = heldLocal.clone().applyQuaternion(root.quaternion).add(root.position);
+      const radius = Math.min(heldSize.x, heldSize.z) * 0.5;
+      const handX = new THREE.Vector3(-0.35, 0, -0.94).normalize().applyQuaternion(gripQ);
+      const handY = new THREE.Vector3(0.94, 0, -0.35).normalize().applyQuaternion(gripQ);
+      const handZ = new THREE.Vector3().crossVectors(handX, handY).normalize();
+      const q2 = new THREE.Quaternion().setFromRotationMatrix(new THREE.Matrix4().makeBasis(handX, handY, handZ));
+      const up = new THREE.Vector3(0, 1, 0).applyQuaternion(gripQ);
+      const palm = center2.clone().addScaledVector(handY, radius + CARRY_PALM).addScaledVector(handX, -0.022).addScaledVector(up, heldSize.y > 0.16 ? -heldSize.y * 0.08 : -5e-3);
+      if (useItemName === "open" || useItemName === "close") {
+        const leftX = new THREE.Vector3(0.35, 0, -0.94).normalize().applyQuaternion(gripQ);
+        const leftY = new THREE.Vector3(-0.94, 0, -0.35).normalize().applyQuaternion(gripQ);
+        const leftZ = new THREE.Vector3().crossVectors(leftX, leftY).normalize();
+        const lq = new THREE.Quaternion().setFromRotationMatrix(new THREE.Matrix4().makeBasis(leftX, leftY, leftZ));
+        const leftPalm = center2.clone().addScaledVector(up, heldSize.y * 0.45).addScaledVector(leftY, radius * 0.65 + CARRY_PALM).addScaledVector(leftX, -0.018);
+        return {
+          R: { position: [palm.x, palm.y, palm.z], quaternion: [q2.x, q2.y, q2.z, q2.w] },
+          L: { position: [leftPalm.x, leftPalm.y, leftPalm.z], quaternion: [lq.x, lq.y, lq.z, lq.w] },
+          grip: 0.85,
+          gripL: 0.8
+        };
+      }
+      return { R: { position: [palm.x, palm.y, palm.z], quaternion: [q2.x, q2.y, q2.z, q2.w] }, grip: 0.85 };
+    }
+    const box2 = new THREE.Box3().setFromObject(root);
+    const center = box2.getCenter(new THREE.Vector3());
+    const forward = new THREE.Vector3(0, 0, -1).applyQuaternion(gripQ).normalize();
+    const back = new THREE.Vector3(0, -1, 0).applyQuaternion(gripQ).normalize();
+    const z = new THREE.Vector3().crossVectors(forward, back).normalize();
+    const y = new THREE.Vector3().crossVectors(z, forward).normalize();
+    const q = new THREE.Quaternion().setFromRotationMatrix(new THREE.Matrix4().makeBasis(forward, y, z));
+    return { R: { position: [center.x, box2.min.y - CARRY_PALM, center.z], quaternion: [q.x, q.y, q.z, q.w] }, grip: CARRY_GRIP };
+  };
+  const gripQuat = new THREE.Quaternion();
   const followHeld = (dt) => {
     const piece = heldPiece;
+    carriedHand = null;
     if (!piece) return;
     camera.updateMatrixWorld(true);
     const root = piece.root;
     let pos;
     const targetQ = tmpQ;
-    if (useItemPlayer) {
+    const hand = thirdActive() ? avatar?.hand?.("R") : void 0;
+    const isDrink = useItemName === "drink" || useItemName === "sip" || useItemName === "chug";
+    if (hand) {
+      const handWorld = hand.getWorldPosition(tmpHand);
+      const yawQ = new THREE.Quaternion().setFromAxisAngle(new THREE.Vector3(0, 1, 0), player.yaw);
+      const pose = useItemPlayer?.pose();
+      const rx = pose ? isDrink ? Math.abs(pose.rotation[0]) * 0.9 : pose.rotation[0] : -heldTilt;
+      const ry = pose ? pose.rotation[1] : 0;
+      const rz = pose ? pose.rotation[2] : 0;
+      gripQuat.copy(yawQ).multiply(new THREE.Quaternion().setFromEuler(new THREE.Euler(Math.max(-1.35, Math.min(1.25, rx)), ry, rz, "XYZ")));
+      targetQ.copy(yawQ).multiply(new THREE.Quaternion().setFromEuler(new THREE.Euler(rx, ry, rz, "XYZ")));
+      targetQ.multiply(new THREE.Quaternion().setFromAxisAngle(new THREE.Vector3(0, 1, 0), heldYaw));
+      const gripOffset = new THREE.Vector3(-0.02, 0.015, -0.04).applyQuaternion(gripQuat);
+      pos = tmpV.copy(handWorld).add(gripOffset);
+    } else if (useItemPlayer) {
       const pose = useItemPlayer.pose();
-      const handQ = new THREE.Quaternion().setFromAxisAngle(new THREE.Vector3(0, 1, 0), player.yaw);
-      pos = tmpV.set(pose.position[0], pose.position[1], pose.position[2]).applyQuaternion(handQ).add(camera.position);
-      const eq = new THREE.Quaternion().setFromEuler(new THREE.Euler(pose.rotation[0], pose.rotation[1], pose.rotation[2], "XYZ"));
-      targetQ.copy(handQ).multiply(eq);
+      const frameQ = avatar?.firstPerson ? camera.quaternion : new THREE.Quaternion().setFromAxisAngle(new THREE.Vector3(0, 1, 0), player.yaw);
+      const raise = isDrink ? Math.max(0, Math.min(1, (pose.position[1] + 0.2) / 0.22)) : 0;
+      const px2 = pose.position[0] + (isDrink ? 0.02 * raise : 0);
+      const py2 = pose.position[1] - (isDrink ? 0.08 * raise : 0);
+      const pz2 = pose.position[2] - (isDrink ? 0.05 * raise : 0);
+      pos = tmpV.set(px2, py2, pz2).applyQuaternion(frameQ).add(camera.position);
+      const rx = isDrink ? Math.abs(pose.rotation[0]) * 0.85 : pose.rotation[0];
+      const eq = new THREE.Quaternion().setFromEuler(new THREE.Euler(rx, pose.rotation[1], pose.rotation[2], "XYZ"));
+      const wristEq = new THREE.Quaternion().setFromEuler(new THREE.Euler(Math.max(-1.35, Math.min(1.25, rx)), pose.rotation[1], pose.rotation[2], "XYZ"));
+      gripQuat.copy(frameQ).multiply(wristEq);
+      targetQ.copy(frameQ).multiply(eq);
       targetQ.multiply(new THREE.Quaternion().setFromAxisAngle(new THREE.Vector3(0, 1, 0), heldYaw));
     } else {
-      pos = tmpV.set(0.05, -0.28, -1.15).applyMatrix4(camera.matrixWorld);
+      const small = heldRadius < 0.22;
+      const holdX = avatar?.firstPerson ? small ? 0.22 : 0.08 : 0.05;
+      const holdY = avatar?.firstPerson ? small ? -0.2 : -0.26 : -0.28;
+      const holdZ = avatar?.firstPerson ? small ? -0.42 : -Math.min(1.15, CARRY_NEAR + heldRadius) : -1.15;
+      pos = tmpV.set(holdX, holdY, holdZ).applyMatrix4(camera.matrixWorld);
+      const baseQ = avatar?.firstPerson && small ? camera.quaternion : new THREE.Quaternion().setFromAxisAngle(new THREE.Vector3(0, 1, 0), player.yaw);
+      gripQuat.copy(baseQ).multiply(new THREE.Quaternion().setFromAxisAngle(new THREE.Vector3(1, 0, 0), Math.max(-1.35, -heldTilt)));
       targetQ.setFromAxisAngle(new THREE.Vector3(0, 1, 0), player.yaw + heldYaw);
-      targetQ.multiply(new THREE.Quaternion().setFromAxisAngle(new THREE.Vector3(1, 0, 0), -heldTilt));
+      if (avatar?.firstPerson && small && heldTilt <= 1e-4) {
+        targetQ.copy(camera.quaternion).multiply(new THREE.Quaternion().setFromAxisAngle(new THREE.Vector3(0, 1, 0), heldYaw));
+      } else {
+        targetQ.multiply(new THREE.Quaternion().setFromAxisAngle(new THREE.Vector3(1, 0, 0), -heldTilt));
+      }
     }
     const k = Math.min(1, (useItemPlayer ? 30 : 16) * dt);
     const px = root.position.x;
@@ -4912,6 +4785,7 @@ function createTestRoom(options) {
       heldVel[2] = (root.position.z - pz) / dt;
     }
     root.updateMatrixWorld(true);
+    if (avatar?.firstPerson && cameraMode === "first") carriedHand = carriedTargets(root, gripQuat);
   };
   const useItem = (useId) => {
     const e = heldEntry;
@@ -4921,11 +4795,13 @@ function createTestRoom(options) {
     const c = fluids.container(e.containerId);
     if (!c) return false;
     if (def.liquids && def.liquids.length > 0 && (!c.liquid || !def.liquids.includes(c.liquid))) return false;
-    if ((useId === "drink" || useId === "sip" || useId === "chug" || useId === "pour" || useId === "pour_out") && c.liters <= 1e-6) {
+    const consuming = useId === "drink" || useId === "sip" || useId === "chug" || useId === "pour" || useId === "pour_out";
+    if (consuming && c.liters <= 1e-6) {
       say(t("hud.empty_container", { name: e.name }));
       return false;
     }
     if (useItemPlayer && !useItemPlayer.done) return false;
+    if (consuming && c.closed) fluids.open(e.containerId);
     useItemPlayer = createItemUse(fluids, e.containerId, def);
     useItemName = def.id;
     action("use_item", t("act.use_item", { name: e.name, use: S.text[`use.${def.id}`] ?? def.id }), { objectId: e.so.objectId, itemId: e.so.itemId, data: { use: def.id } });
@@ -4941,7 +4817,7 @@ function createTestRoom(options) {
   };
   const TAP_ID = "room_tap";
   const TAP_RATE = 0.25;
-  fluids.addTap({ id: TAP_ID, position: arena.tapSpout, liquid: "water", rate: TAP_RATE, temperature: 16, on: false });
+  if (arena.tapSpout) fluids.addTap({ id: TAP_ID, position: arena.tapSpout, liquid: "water", rate: TAP_RATE, temperature: 16, on: false });
   const isTapOn = () => fluids.taps().some((x) => x.id === TAP_ID && x.on);
   const toggleTap = (on = !isTapOn()) => {
     fluids.setTap(TAP_ID, on);
@@ -5047,10 +4923,11 @@ function createTestRoom(options) {
         if (heldEntry?.uses[0]) useItem(heldEntry.uses[0]);
         break;
       case "KeyC":
-        if (heldEntry?.uses[1]) useItem(heldEntry.uses[1]);
+        if (heldEntry?.uses[1] && !(options.crouch?.keys ?? ["KeyC"]).includes("KeyC")) useItem(heldEntry.uses[1]);
         break;
       case "KeyV":
         if (heldEntry?.uses[2]) useItem(heldEntry.uses[2]);
+        else if (avatar && !e.shiftKey) setCameraMode(cameraMode === "first" ? "third" : "first");
         else kick();
         break;
       case "KeyT":
@@ -5098,7 +4975,7 @@ function createTestRoom(options) {
     const joints = st.joints.filter((j) => j.a === r.part || j.b === r.part).map((j) => ({
       id: j.id,
       kind: dStrings.jointKinds[j.kind] ?? j.kind,
-      tools: JOINT_DEFAULTS2[j.kind].tools.map((k) => dStrings.toolKinds[k] ?? k),
+      tools: JOINT_DEFAULTS[j.kind].tools.map((k) => dStrings.toolKinds[k] ?? k),
       open: j.open,
       progress: j.progress
     }));
@@ -5138,6 +5015,7 @@ function createTestRoom(options) {
   const roomMetrics = createRoomMetrics({ gl, destruction: renderer, fluids: fluidView, effects: vfx.world, ids: roomMetricIds, blast: () => lastBlast });
   let qualityName = quality;
   const syncContainers = (sdt) => {
+    const drinkingHeld = useItemPlayer !== null && (useItemName === "drink" || useItemName === "sip" || useItemName === "chug");
     for (const e of entries.values()) {
       if (!e.containerId) continue;
       const host2 = hostOf(e);
@@ -5146,7 +5024,8 @@ function createTestRoom(options) {
       const p = tmpV.set(e.fluidOffset[0], e.fluidOffset[1], e.fluidOffset[2]).applyMatrix4(host2.root.matrixWorld);
       const vel = sdt > 0 ? [(p.x - e.last[0]) / sdt, (p.y - e.last[1]) / sdt, (p.z - e.last[2]) / sdt] : void 0;
       e.last = [p.x, p.y, p.z];
-      fluids.setTransform(e.containerId, [p.x, p.y, p.z], [q.x, q.y, q.z, q.w], vel);
+      const rot = drinkingHeld && e === heldEntry ? [0, 0, 0, 1] : [q.x, q.y, q.z, q.w];
+      fluids.setTransform(e.containerId, [p.x, p.y, p.z], rot, vel);
     }
   };
   const syncLiters = () => {
@@ -5172,6 +5051,7 @@ function createTestRoom(options) {
     if (paused) return;
     simTime += dt;
     stepWalk(dt);
+    stepStrikes(dt);
     const reps = fastForward ? 10 : 1;
     updateAnimations(dt);
     updateItemUse(dt);
@@ -5210,6 +5090,7 @@ function createTestRoom(options) {
   const update = (dt) => {
     if (!ownsLoop) roomMetrics.frame(dt);
     player.update(dt);
+    stepAvatar(paused ? 0 : dt);
     if (tiltKey || heldTilt > 0) {
       heldTilt = Math.max(0, Math.min(2.4, heldTilt + (tiltKey ? 2.2 : -3) * dt));
     }
@@ -5221,6 +5102,7 @@ function createTestRoom(options) {
     }
     if (!paused) followHeld(dt);
     stepSim(dt * timeScale);
+    stepFirstPerson(paused ? 0 : dt);
     if (progress && simTime - progress.at > 0.25) progress = null;
     hudAcc += dt;
     if (hudAcc >= 0.1 && ui) {
@@ -5256,6 +5138,7 @@ function createTestRoom(options) {
       tap: isTapOn(),
       blast: { shelter: blastOn("shelter"), fragmentHits: blastOn("fragmentHits"), confinement: blastOn("confinement") },
       quality: qualityName,
+      camera: avatar ? cameraMode : null,
       objects: [...entries.values()].filter((e) => !e.arena).length
     };
   };
@@ -5457,6 +5340,8 @@ function createTestRoom(options) {
     environment,
     groundAt,
     effects: vfx,
+    loading,
+    ...options.blastShove ? { blastShove: options.blastShove } : {},
     tool: () => ({
       weapon: toolId,
       category: tool.def.category,
@@ -5480,6 +5365,15 @@ function createTestRoom(options) {
       flushEvents(toolId, tool);
       return result;
     },
+    player: () => ({
+      position: player.position,
+      yaw: player.yaw,
+      pitch: player.pitch,
+      crouching: false,
+      speed: player.speed,
+      running: player.running,
+      cameraMode: "first"
+    }),
     configureTool(settings) {
       const condition = settings[SETTING_IDS.condition];
       const ammoQuality = settings[SETTING_IDS.ammoQuality];
@@ -5501,8 +5395,14 @@ function createTestRoom(options) {
       frameListeners.add(update2);
       return () => frameListeners.delete(update2);
     },
-    log(text, data) {
-      action("module_note", text, { data });
+    setHandTargets(source) {
+      handSource = source;
+      return () => {
+        if (handSource === source) handSource = null;
+      };
+    },
+    log(text, data, type) {
+      action(type ?? "module_note", text, { data });
     },
     addBlocker(blocked) {
       blockers.add(blocked);
@@ -5513,13 +5413,17 @@ function createTestRoom(options) {
       return () => clearListeners.delete(listener);
     }
   };
+  let sendingInitial = false;
   const lendBench = (store) => ({
     value: store.value,
     layer: store.layer,
     onChange: store.onChange,
     patch: store.patch,
     sheet: store.setSheet,
-    look: (eye, target) => room.look(eye, target)
+    // the initial and restored values only set the module's state: they do not move the player's camera (`ModuleArea.view` is how a module asks for a view when its area opens)
+    look: (eye, target) => {
+      if (!sendingInitial) 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) })));
@@ -5531,6 +5435,29 @@ function createTestRoom(options) {
     for (const p of r.problems) fail(`bench: ${p}`);
     return r.ok ? store : null;
   };
+  const LIGHTS_CHECK_MS = 250;
+  const warmUp = () => {
+    const probes = [renderer.warmUpProbes(), vfx.warmUpProbes(), fluidView.warmUpProbes()];
+    const groups = probes.map((probe) => probe.group);
+    scene.add(...groups);
+    gl.render(scene, camera);
+    scene.remove(...groups);
+    for (const probe of probes) probe.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);
+  };
   const loadModule = (mod) => {
     const report = { module: mod.id, items: [], scenarios: [], ok: true, problems: [] };
     const fail = (problem) => {
@@ -5546,6 +5473,7 @@ function createTestRoom(options) {
         build: (T) => ti.build(T),
         spec: ti.spec,
         movable: ti.movable,
+        slow: ti.slow,
         fluid: ti.fluid,
         weapon: ti.weapon,
         impl: ti.impl,
@@ -5560,8 +5488,9 @@ function createTestRoom(options) {
       report.items.push(item.id);
       let partIds = [];
       const base = { module: mod.id, item: item.id };
+      let checked;
       try {
-        const root = item.build(THREE);
+        const root = checked = buildRoot(item);
         root.updateMatrixWorld(true);
         if (item.impl) {
           const probe = item.impl(root, `${item.id}_check`);
@@ -5583,6 +5512,7 @@ function createTestRoom(options) {
         moduleCheck(false, t("mod.destructible_fail", { name: item.name, problems: msg }), { ...base, check: "destructible", problems: [msg] }, item.id);
         fail(`${item.id}: ${msg}`);
       }
+      if (checked) letGo(checked);
       for (const clip of item.animations ?? []) {
         const r = checkAnimation(clip, partIds);
         moduleCheck(r.ok, r.ok ? t("mod.animation_ok", { name: item.name, clip: clip.id, seconds: num(clip.duration, 1) }) : t("mod.animation_fail", { name: item.name, clip: clip.id, problems: r.problems.join("; ") }), { ...base, check: "animation", clip: clip.id, problems: r.problems }, item.id);
@@ -5618,12 +5548,17 @@ function createTestRoom(options) {
       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();
+    sendingInitial = true;
+    try {
+      bench?.sendInitial();
+    } finally {
+      sendingInitial = false;
+    }
     showBench();
     ui?.refresh();
     return report;
   };
-  const allScenarios = () => [...makeScenarios(t, num, locale), ...extraScenarios];
+  const allScenarios = () => [...extraScenarios];
   let scenarioRunning = false;
   const step = (seconds) => {
     const dt = seconds > 6 ? 1 / 30 : FIXED_DT;
@@ -5676,8 +5611,13 @@ function createTestRoom(options) {
     return report;
   };
   const layArea = (layout) => {
-    const holders = layout.placements.filter((p) => p.surface);
-    const rest = layout.placements.filter((p) => !p.surface);
+    const known = layout.placements.filter((p) => {
+      if (catalogMap.has(p.item)) return true;
+      action("area_skip", t("act.area_skip", { item: p.item }), { itemId: p.item });
+      return false;
+    });
+    const holders = known.filter((p) => p.surface);
+    const rest = known.filter((p) => !p.surface);
     const placed = [...holders, ...rest].map((p) => {
       const so = spawn(p.item, p.position, p.rotationY ?? 0);
       if (p.surface) {
@@ -5693,6 +5633,10 @@ function createTestRoom(options) {
     if (layout.view) room.look(layout.view.eye, layout.view.target);
     return placed.map(({ so }) => so);
   };
+  const areaLabel = (area) => {
+    const mod = [...modules.values()].find((m) => m.id === area || m.group === area);
+    return mod?.group ?? S.groups[area] ?? area;
+  };
   const openArea = (area) => {
     clear();
     const mod = [...modules.values()].find((m) => m.id === area || m.group === area);
@@ -5805,14 +5749,59 @@ function createTestRoom(options) {
     },
     equip,
     openArea,
+    openAreaAsync: (area) => loading.busy(t("loading.open_area", { area: areaLabel(area) }), () => openArea(area)),
+    loading,
+    busy: (label, work, busyOptions) => loading.busy(label, work, busyOptions),
     loadModule,
+    warmUp: () => {
+      warmUp();
+      warmUpEffects();
+    },
     animations: animationsOf,
     playAnimation,
     bench(moduleId) {
       const id = moduleId ?? activeBench;
       return (id ? benches.get(id) : void 0) ?? null;
     },
-    applyCamera: () => vfx.applyCamera(),
+    applyCamera: () => {
+      const back = applyThirdView();
+      const shake = vfx.applyCamera();
+      return () => {
+        shake();
+        back();
+      };
+    },
+    setAvatar,
+    get avatar() {
+      return avatar;
+    },
+    setAvatarState(state) {
+      if (state.crouch !== void 0) {
+        crouchForced = state.crouch;
+        avatarState.crouch = state.crouch || player.crouching;
+      }
+      if (state.down !== void 0) avatarState.down = state.down;
+      if (state.armed !== void 0) armedForced = state.armed;
+    },
+    avatarState: () => ({ ...avatarState }),
+    handState: () => ({ ...lastHand }),
+    setDebugCamera(view) {
+      if (!view) {
+        debugView = null;
+        return;
+      }
+      debugView ?? (debugView = new THREE.PerspectiveCamera(60, camera.aspect, 0.01, 200));
+      debugView.fov = view.fov ?? 40;
+      debugView.aspect = camera.aspect;
+      debugView.position.set(...view.position);
+      debugView.lookAt(...view.target);
+      debugView.updateProjectionMatrix();
+      debugView.updateMatrixWorld(true);
+    },
+    setCameraMode,
+    get cameraMode() {
+      return cameraMode;
+    },
     metrics() {
       return { room: roomMetrics.sample(), module: moduleMetrics() };
     },
@@ -5827,6 +5816,7 @@ function createTestRoom(options) {
       window.removeEventListener("resize", onResize);
       player.dispose();
       ui?.dispose();
+      loading.dispose();
       renderer.dispose();
       vfx.dispose();
       craterPatch?.dispose();
@@ -5841,6 +5831,17 @@ function createTestRoom(options) {
       }
     }
   };
+  const slowly = (moduleId, controlId, run) => {
+    const control = benches.get(moduleId)?.controls().find((c) => c.id === controlId);
+    const slow = control?.slow;
+    if (!slow) {
+      run();
+      return;
+    }
+    void loading.busy(typeof slow === "string" ? slow : control.name, run).catch((error) => {
+      action("bench_failed", t("act.bench_failed", { name: control.name, error: error instanceof Error ? error.message : String(error) }), { data: { module: moduleId, control: controlId } });
+    });
+  };
   let ui = null;
   if (options.ui !== false) {
     const groups = () => {
@@ -5860,7 +5861,9 @@ function createTestRoom(options) {
       groups,
       loadout: () => loadout.map((id) => ({ id, name: arsenal.name(id) })),
       onSpawn: (id) => {
-        spawn(id);
+        const item = catalogMap.get(id);
+        if (item?.slow) void loading.busy(typeof item.slow === "string" ? item.slow : t("loading.spawn", { name: item.name }), () => spawn(id));
+        else spawn(id);
       },
       onEquip: (itemId) => {
         const w = catalogMap.get(itemId)?.weapon;
@@ -5900,13 +5903,13 @@ function createTestRoom(options) {
       },
       onResize: resize,
       onControl: (id, value) => {
-        if (activeBench) benches.get(activeBench)?.set(id, value);
+        if (activeBench) slowly(activeBench, id, () => 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);
+        if (activeBench) slowly(activeBench, id, () => benches.get(activeBench)?.act(id));
       }
     });
     ui.hud(hudState());
@@ -5916,15 +5919,32 @@ function createTestRoom(options) {
   if (ownRenderer && typeof requestAnimationFrame === "function") {
     let last = performance.now();
     ownsLoop = true;
+    let nextLightsCheck = 0;
+    let warmedLights = "";
+    const lightsKey = () => {
+      let key = "";
+      scene.traverseVisible((object) => {
+        if (object.isLight) key += `${object.type[0]}${object.castShadow ? "s" : ""}`;
+      });
+      return key;
+    };
     const loop = (now) => {
       raf = requestAnimationFrame(loop);
+      if (now >= nextLightsCheck) {
+        nextLightsCheck = now + LIGHTS_CHECK_MS;
+        const key = lightsKey();
+        if (key !== warmedLights) {
+          warmedLights = key;
+          warmUp();
+        }
+      }
       const realDelta = (now - last) / 1e3;
       roomMetrics.frame(realDelta);
       const dt = Math.min(0.05, realDelta);
       last = now;
       if (!scenarioRunning) update(dt);
-      const restoreCamera = vfx.applyCamera();
-      gl.render(scene, camera);
+      const restoreCamera = room.applyCamera();
+      gl.render(scene, debugView ?? camera);
       restoreCamera();
       roomMetrics.rendered();
     };
@@ -5933,6 +5953,7 @@ function createTestRoom(options) {
   if (options.initial) {
     for (const [i, id] of options.initial.entries()) spawn(id, [(i - (options.initial.length - 1) / 2) * 1.3, 0, 0.5]);
   }
+  if (options.avatar) setAvatar(options.avatar);
   if (options.area) openArea(options.area);
   return room;
 }
@@ -5940,20 +5961,21 @@ function structuredCloneSpec(spec) {
   return JSON.parse(JSON.stringify(spec));
 }
 export {
-  DEMO_ITEMS,
-  DEMO_MATERIALS,
+  DEFAULT_HAND_STANCES,
+  DEFAULT_STRIKE_CLIPS,
+  LOADING_CLASS,
+  LOADING_CSS,
   MATERIAL_COLORS,
-  SCENARIOS,
   brickWallSpec,
   buildFromSpec,
+  createLoading,
   createLog,
   createTestRoom,
   decodeBenchState,
-  demoItems,
   encodeBenchState,
+  loadingMarkup,
   locales,
-  makeScenarios,
-  resolveStrings,
-  scenariosFor
+  nextPaint,
+  resolveStrings
 };
 //# sourceMappingURL=index.js.map