@adatechnology/game-test-room 0.0.0-stage → 0.1.0

package/dist/index.js

@@ -0,0 +1,4430 @@
+// src/room.ts
+import { createDestruction, JOINT_DEFAULTS as JOINT_DEFAULTS2, resolveStrings as resolveDestructionStrings } from "@adatechnology/game-destruction";
+import { createDestructionRenderer, specFromObject3D } from "@adatechnology/game-destruction-three";
+import { createArsenal, DEFAULT_LOADOUT } from "@adatechnology/game-weapons";
+import { createFluids, createItemUse, ITEM_USES, resolveStrings as resolveFluidStrings } from "@adatechnology/game-fluids";
+import { createFluidRenderer } from "@adatechnology/game-fluids-three";
+import { checkAnimation, checkDestructible } from "@adatechnology/game-contracts";
+
+// src/items.ts
+import { buildFrame } from "@adatechnology/game-destruction";
+
+// 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/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.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.",
+    "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.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.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 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",
+    "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.quality": "Quality",
+    "ui.quality.low": "low",
+    "ui.quality.medium": "medium",
+    "ui.quality.high": "high",
+    "ui.equip": "Equip as a tool",
+    "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 after a few 9 mm shots",
+    "sc.glass_shatters.check": "Glass pane: broken after {shots} shot(s) into {n} shards (expected: broken, 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.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)"
+  }
+};
+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.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.",
+    "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.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.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 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",
+    "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.quality": "Qualidade",
+    "ui.quality.low": "baixa",
+    "ui.quality.medium": "m\xE9dia",
+    "ui.quality.high": "alta",
+    "ui.equip": "Equipar como ferramenta",
+    "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 depois de alguns tiros de 9 mm",
+    "sc.glass_shatters.check": "Vidro: quebrou depois de {shots} tiro(s) em {n} cacos (esperado: quebrado, 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.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)"
+  }
+};
+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"));
+    }
+  }
+  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/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() {
+  let list = [];
+  let seq = 0;
+  let clock = () => 0;
+  let beforeRead = null;
+  const listeners = /* @__PURE__ */ new Set();
+  const keyed = /* @__PURE__ */ new Map();
+  const read = () => {
+    beforeRead?.();
+    return list;
+  };
+  const emit = (e, updated) => {
+    for (const fn of listeners) {
+      try {
+        fn(e, updated);
+      } catch {
+      }
+    }
+  };
+  const add = (entry) => {
+    const { t, ...rest } = entry;
+    const e = { seq: seq++, t: Math.round((t ?? clock()) * 1e3) / 1e3, ...rest };
+    list.push(e);
+    if (list.length > MAX_ENTRIES) list = list.slice(list.length - MAX_ENTRIES);
+    emit(e, false);
+    return e;
+  };
+  const log = {
+    add,
+    coalesce(key, entry, windowS = 1) {
+      const now = entry.t ?? clock();
+      const k = keyed.get(key);
+      if (k && now - k.last <= windowS && list.includes(k.entry)) {
+        const { t: _t, ...rest } = entry;
+        k.count++;
+        Object.assign(k.entry, rest);
+        k.entry.data = { ...rest.data ?? {}, updates: k.count };
+        k.last = now;
+        emit(k.entry, true);
+        return k.entry;
+      }
+      const e = add(entry);
+      keyed.set(key, { entry: e, last: now, count: 1 });
+      return e;
+    },
+    setBeforeRead(fn) {
+      beforeRead = fn;
+    },
+    setClock(fn) {
+      clock = fn;
+    },
+    entries(filter) {
+      const all = read();
+      if (!filter) return all.slice();
+      return all.filter(
+        (e) => (!filter.channel || e.channel === filter.channel) && (!filter.type || e.type === filter.type) && (!filter.objectId || e.objectId === filter.objectId)
+      );
+    },
+    clear() {
+      beforeRead?.();
+      list = [];
+      keyed.clear();
+    },
+    toJSON: () => JSON.stringify(read(), null, 2),
+    toNDJSON: () => read().map((e) => JSON.stringify(e)).join("\n") + (list.length ? "\n" : ""),
+    toText: () => read().map((e) => `[${formatTime(e.t)}] ${e.channel.padEnd(6)} ${e.text}`).join("\n"),
+    download(format = "ndjson") {
+      if (typeof document === "undefined" || typeof Blob === "undefined" || typeof URL === "undefined" || !URL.createObjectURL) return;
+      const body = format === "json" ? log.toJSON() : format === "txt" ? log.toText() : log.toNDJSON();
+      const mime = format === "json" ? "application/json" : "text/plain";
+      const url = URL.createObjectURL(new Blob([body], { type: mime }));
+      const a = document.createElement("a");
+      a.href = url;
+      a.download = `test-room-log.${format}`;
+      document.body.appendChild(a);
+      a.click();
+      a.remove();
+      setTimeout(() => URL.revokeObjectURL(url), 1e3);
+    },
+    summary() {
+      const byType = {};
+      const byMaterial = {};
+      const objects = /* @__PURE__ */ new Set();
+      let destroyed = 0;
+      for (const e of read()) {
+        byType[e.type] = (byType[e.type] ?? 0) + 1;
+        if (e.material) byMaterial[e.material] = (byMaterial[e.material] ?? 0) + 1;
+        if (e.objectId) objects.add(e.objectId);
+        if (e.type === "destroyed") destroyed++;
+      }
+      return { byType, byMaterial, objects: objects.size, destroyed };
+    },
+    on(fn) {
+      listeners.add(fn);
+      return () => listeners.delete(fn);
+    }
+  };
+  return log;
+}
+
+// src/narrate.ts
+var SKIP_DAMAGE = /* @__PURE__ */ new Set(["fire", "heat"]);
+function createNarrator(c) {
+  const { t, num } = c;
+  const materialMemo = /* @__PURE__ */ new Map();
+  const findPart = (objectId, partId) => {
+    const p = c.world.part(objectId, partId) ?? c.locatePart?.(objectId, partId)?.part ?? null;
+    if (p) materialMemo.set(`${objectId}|${partId}`, p.material);
+    return p;
+  };
+  const plural = (key, n) => t(`${key}.${n === 1 ? "one" : "other"}`, { n });
+  const pieces = (n) => plural("count.piece", n);
+  const joints = (n) => plural("count.joint", n);
+  const xz = (x, z) => t("coords", { x: num(x, 1), z: num(z, 1) });
+  const where = (objectId, partId) => {
+    const p = findPart(objectId, partId);
+    const m = p?.material ?? materialMemo.get(`${objectId}|${partId}`);
+    return `${c.nameOf(objectId)} \u203A ${partId}${m ? ` (${c.materialName(m)})` : ""}`;
+  };
+  const stateOf = (objectId, partId) => {
+    const p = findPart(objectId, partId);
+    if (!p) return void 0;
+    const s = {
+      status: p.status,
+      hp: Math.round(p.hp * 10) / 10,
+      maxHp: Math.round(p.maxHp * 10) / 10,
+      temperature: Math.round(p.temperature),
+      char: Math.round(p.char * 100) / 100,
+      melt: Math.round(p.melt * 100) / 100
+    };
+    if (p.liters !== void 0) s.liters = Math.round(p.liters * 1e3) / 1e3;
+    return s;
+  };
+  const base = (ev, part) => ({
+    channel: "event",
+    objectId: ev.object,
+    itemId: c.itemIdOf(ev.object),
+    part,
+    material: part ? findPart(ev.object, part)?.material ?? materialMemo.get(`${ev.object}|${part}`) : void 0,
+    state: part ? stateOf(ev.object, part) : void 0
+  });
+  const hpText = (obj, part) => {
+    const p = findPart(obj, part);
+    return p ? `hp ${num(p.hp, 0)}/${num(p.maxHp, 0)}` : "";
+  };
+  const isLost = (obj, part) => {
+    const st = findPart(obj, part)?.status;
+    return st === "broken" || st === "melted" || st === "ashes";
+  };
+  const crackAcc = /* @__PURE__ */ new Map();
+  const damageAcc = /* @__PURE__ */ new Map();
+  const stressAt = /* @__PURE__ */ new Map();
+  const leakAt = /* @__PURE__ */ new Map();
+  const list = (names) => names.length > 6 ? `${names.slice(0, 6).join(", ")}\u2026` : names.join(", ");
+  const events = (batch) => {
+    const now = c.now();
+    const damage = /* @__PURE__ */ new Map();
+    const holes = /* @__PURE__ */ new Map();
+    const dents = /* @__PURE__ */ new Map();
+    for (const ev of batch) {
+      if (ev.type !== "damage") continue;
+      const k = `${ev.object}|${ev.part}`;
+      const prev = damage.get(k);
+      damage.set(k, { amount: (prev?.amount ?? 0) + ev.amount, type: ev.damageType });
+    }
+    const lostJoints = /* @__PURE__ */ new Map();
+    const openJoints = /* @__PURE__ */ new Map();
+    const fireParts = /* @__PURE__ */ new Map();
+    const outParts = /* @__PURE__ */ new Map();
+    for (const ev of batch) {
+      if (ev.type === "detach") {
+        if (ev.by === "part_lost") {
+          const [a, b] = ev.parts;
+          const lost = isLost(ev.object, a) && !isLost(ev.object, b) ? a : isLost(ev.object, b) && !isLost(ev.object, a) ? b : isLost(ev.object, a) ? a : b;
+          const key = `${ev.object}|${lost}`;
+          const g = lostJoints.get(key) ?? { obj: ev.object, part: lost, joints: 0, groups: 0, merged: false };
+          g.joints++;
+          g.groups = ev.groups.length;
+          lostJoints.set(key, g);
+        } else {
+          const key = `${ev.object}|${ev.by}`;
+          const g = openJoints.get(key) ?? { obj: ev.object, by: ev.by, list: [], groups: 0, done: false };
+          const [a, b] = ev.parts;
+          g.list.push({ joint: ev.joint, a, b });
+          g.groups = ev.groups.length;
+          openJoints.set(key, g);
+        }
+      } else if (ev.type === "ignite") {
+        const g = fireParts.get(ev.object) ?? { obj: ev.object, parts: [], temp: 0, done: false };
+        g.parts.push(ev.part);
+        g.temp = Math.max(g.temp, findPart(ev.object, ev.part)?.temperature ?? 0);
+        fireParts.set(ev.object, g);
+      } else if (ev.type === "extinguish") {
+        const g = outParts.get(ev.object) ?? { obj: ev.object, parts: [], done: false };
+        g.parts.push(ev.part);
+        outParts.set(ev.object, g);
+      }
+    }
+    const lostTail = (key) => {
+      const g = lostJoints.get(key);
+      if (!g) return "";
+      g.merged = true;
+      return t("ev.lost.tail", { joints: joints(g.joints), pieces: pieces(g.groups) });
+    };
+    const lostData = (key) => {
+      const g = lostJoints.get(key);
+      return g ? { jointsOpened: g.joints, pieces: g.groups } : {};
+    };
+    for (const ev of batch) {
+      switch (ev.type) {
+        case "damage":
+          break;
+        case "dent": {
+          const k = `${ev.object}|${ev.part}`;
+          const d = damage.get(k);
+          damage.delete(k);
+          const mm = ev.dent.depth * 1e3;
+          const prev = dents.get(k);
+          if (prev) {
+            const n = Number(prev.data?.count ?? 1) + 1;
+            const deepest = Math.max(Number(prev.data?.depthMm ?? 0), mm);
+            prev.text = t("ev.dents", { where: where(ev.object, ev.part), n, mm: num(deepest, 0), hp: hpText(ev.object, ev.part) });
+            prev.data = { ...prev.data, count: n, depthMm: Math.round(deepest * 10) / 10 };
+            break;
+          }
+          dents.set(
+            k,
+            c.log.add({
+              ...base(ev, ev.part),
+              type: "dent",
+              text: t("ev.dent", { where: where(ev.object, ev.part), mm: num(mm, 0), hp: hpText(ev.object, ev.part) }),
+              data: { count: 1, depthMm: Math.round(mm * 10) / 10, radius: ev.dent.radius, damage: d?.amount, point: ev.worldPoint, source: ev.source }
+            })
+          );
+          break;
+        }
+        case "hole": {
+          const k = `${ev.object}|${ev.part}`;
+          const d = damage.get(k);
+          damage.delete(k);
+          const mm = ev.hole.diameter * 1e3;
+          const prev = holes.get(k);
+          if (prev) {
+            const n = Number(prev.data?.count ?? 1) + 1;
+            const through = Number(prev.data?.throughCount ?? 0) + (ev.hole.through ? 1 : 0);
+            prev.text = t("ev.holes", { where: where(ev.object, ev.part), n, mm: num(mm, 0), thr: through, hp: hpText(ev.object, ev.part) });
+            prev.data = { ...prev.data, count: n, throughCount: through, through: through > 0 };
+            break;
+          }
+          holes.set(
+            k,
+            c.log.add({
+              ...base(ev, ev.part),
+              type: "hole",
+              text: t(ev.hole.through ? "ev.hole.through" : "ev.hole.stuck", { where: where(ev.object, ev.part), mm: num(mm, 0), hp: hpText(ev.object, ev.part) }),
+              data: { count: 1, throughCount: ev.hole.through ? 1 : 0, diameterMm: Math.round(mm * 10) / 10, through: ev.hole.through, damage: d?.amount, point: ev.worldPoint, source: ev.source }
+            })
+          );
+          break;
+        }
+        case "crack": {
+          const k = `${ev.object}|${ev.part}`;
+          const d = damage.get(k);
+          damage.delete(k);
+          const loaded = (findPart(ev.object, ev.part)?.stress ?? 0) > 0.8 && ev.source === void 0;
+          const cm = ev.crack.length * 100;
+          if (loaded) {
+            const acc = crackAcc.get(k);
+            const n = acc && now - acc.last <= 1 ? acc.n + 1 : 1;
+            const longest = acc && n > 1 ? Math.max(acc.cm, cm) : cm;
+            crackAcc.set(k, { n, cm: longest, last: now });
+            c.log.coalesce(
+              `crack:${k}`,
+              {
+                ...base(ev, ev.part),
+                type: "crack",
+                text: t("ev.cracks", { where: where(ev.object, ev.part), n, cm: num(longest, 0), hp: hpText(ev.object, ev.part) }),
+                data: { rays: ev.crack.rays, lengthM: ev.crack.length, count: n, underLoad: true }
+              },
+              1
+            );
+            break;
+          }
+          c.log.add({
+            ...base(ev, ev.part),
+            type: "crack",
+            text: t("ev.crack", { where: where(ev.object, ev.part), rays: ev.crack.rays, cm: num(cm, 0), hp: hpText(ev.object, ev.part) }),
+            data: { rays: ev.crack.rays, lengthM: ev.crack.length, damage: d?.amount, source: ev.source }
+          });
+          break;
+        }
+        case "ricochet":
+          c.log.add({
+            ...base(ev, ev.part),
+            type: "ricochet",
+            text: t("ev.ricochet", { where: where(ev.object, ev.part), energy: num(ev.energy, 0) }),
+            data: { energy: ev.energy, direction: ev.direction }
+          });
+          break;
+        case "leak": {
+          const k = `${ev.object}|${ev.part}`;
+          const liquid = c.liquidName(ev.fluid);
+          const hole = holes.get(k);
+          const rate = num(ev.rate, 2);
+          leakAt.set(ev.object, now);
+          if (hole) {
+            hole.text += t("ev.leak.tail", { liquid, rate });
+            hole.data = { ...hole.data, leak: { fluid: ev.fluid, ratePerS: ev.rate, pressurized: ev.pressurized } };
+          } else {
+            c.log.add({ ...base(ev, ev.part), type: "leak", text: t("ev.leak.alone", { where: where(ev.object, ev.part), liquid, rate }), data: { fluid: ev.fluid, ratePerS: ev.rate } });
+          }
+          break;
+        }
+        case "fracture": {
+          const k = `${ev.object}|${ev.part}`;
+          const d = damage.get(k);
+          damage.delete(k);
+          c.log.add({
+            ...base(ev, ev.part),
+            type: "fracture",
+            text: t(`ev.fracture.${ev.style}`, { where: where(ev.object, ev.part), n: ev.fragments.length }) + lostTail(k),
+            data: { style: ev.style, fragments: ev.fragments.length, damage: d?.amount, point: ev.point, source: ev.source, ...lostData(k) }
+          });
+          break;
+        }
+        case "detach": {
+          if (ev.by === "part_lost") {
+            const [a2, b2] = ev.parts;
+            const lost = isLost(ev.object, a2) && !isLost(ev.object, b2) ? a2 : isLost(ev.object, b2) && !isLost(ev.object, a2) ? b2 : isLost(ev.object, a2) ? a2 : b2;
+            const key2 = `${ev.object}|${lost}`;
+            const g2 = lostJoints.get(key2);
+            if (!g2 || g2.merged) break;
+            const hasOwnLine = batch.some((e) => (e.type === "fracture" || e.type === "burnout") && e.object === ev.object && e.part === lost);
+            if (hasOwnLine) break;
+            g2.merged = true;
+            const status = findPart(ev.object, lost)?.status;
+            const verb = t(`lost.${status === "ashes" ? "ashes" : status === "melted" ? "melted" : "broken"}`);
+            c.log.add({
+              ...base(ev, lost),
+              type: "detach",
+              text: t("ev.lost.alone", { where: where(ev.object, lost), verb, joints: joints(g2.joints), pieces: pieces(g2.groups) }),
+              data: { parts: [a2, b2], by: ev.by, ...lostData(key2) }
+            });
+            break;
+          }
+          const key = `${ev.object}|${ev.by}`;
+          const g = openJoints.get(key);
+          if (!g || g.done) break;
+          g.done = true;
+          const [a, b] = ev.parts;
+          const many = g.list.length > 1;
+          c.log.add({
+            channel: "event",
+            type: "detach",
+            objectId: ev.object,
+            itemId: c.itemIdOf(ev.object),
+            text: many ? t(`ev.detach.many.${ev.by === "tool" ? "tool" : "break"}`, { obj: c.nameOf(ev.object), joints: joints(g.list.length), pieces: pieces(g.groups) }) : t("ev.detach", { obj: c.nameOf(ev.object), a, b, by: t(`by.${ev.by}`), pieces: pieces(g.groups) }),
+            data: { joint: ev.joint, joints: g.list.map((j) => j.joint), parts: ev.parts, by: ev.by, groups: g.groups }
+          });
+          break;
+        }
+        case "disassemble_progress": {
+          const pct = Math.round(ev.progress * 100);
+          const kind = kindOf(ev.object, ev.joint);
+          const [a, b] = ev.joint.split("~");
+          c.log.coalesce(
+            `dis:${ev.object}:${ev.joint}`,
+            {
+              channel: "event",
+              type: "disassemble_progress",
+              objectId: ev.object,
+              itemId: c.itemIdOf(ev.object),
+              text: t("ev.disassemble", { obj: c.nameOf(ev.object), a: a ?? ev.joint, b: b ?? "", kind: kind ? c.jointKind(kind) : t("joint.generic"), tool: c.toolName(ev.tool), pct }),
+              data: { joint: ev.joint, tool: ev.tool, progress: ev.progress }
+            },
+            1.5
+          );
+          break;
+        }
+        case "ignite": {
+          const g = fireParts.get(ev.object);
+          if (g && g.parts.length >= 3) {
+            if (g.done) break;
+            g.done = true;
+            c.log.add({
+              channel: "event",
+              type: "ignite",
+              objectId: ev.object,
+              itemId: c.itemIdOf(ev.object),
+              text: t("ev.ignite.many", { obj: c.nameOf(ev.object), n: g.parts.length, temp: num(g.temp, 0), parts: list(g.parts) }),
+              data: { parts: g.parts, temperature: Math.round(g.temp) }
+            });
+            break;
+          }
+          c.log.add({ ...base(ev, ev.part), type: "ignite", text: t("ev.ignite", { where: where(ev.object, ev.part), temp: num(findPart(ev.object, ev.part)?.temperature ?? 0, 0) }) });
+          break;
+        }
+        case "extinguish": {
+          const g = outParts.get(ev.object);
+          if (g && g.parts.length >= 3) {
+            if (g.done) break;
+            g.done = true;
+            c.log.add({
+              channel: "event",
+              type: "extinguish",
+              objectId: ev.object,
+              itemId: c.itemIdOf(ev.object),
+              text: t("ev.extinguish.many", { obj: c.nameOf(ev.object), n: g.parts.length, parts: list(g.parts) }),
+              data: { parts: g.parts }
+            });
+            break;
+          }
+          c.log.add({ ...base(ev, ev.part), type: "extinguish", text: t("ev.extinguish", { where: where(ev.object, ev.part) }) });
+          break;
+        }
+        case "burnout": {
+          const k = `${ev.object}|${ev.part}`;
+          c.log.add({ ...base(ev, ev.part), type: "burnout", text: t("ev.burnout", { where: where(ev.object, ev.part) }) + lostTail(k), data: lostData(k) });
+          break;
+        }
+        case "melt":
+          c.log.coalesce(
+            `melt:${ev.object}:${ev.part}`,
+            { ...base(ev, ev.part), type: "melt", text: t("ev.melt", { where: where(ev.object, ev.part), pct: Math.round(ev.melt * 100) }), data: { melt: ev.melt } },
+            2
+          );
+          break;
+        case "drip":
+          c.log.coalesce(`drip:${ev.object}:${ev.part}`, { ...base(ev, ev.part), type: "drip", text: t("ev.drip", { where: where(ev.object, ev.part) }), data: { point: ev.point } }, 2);
+          break;
+        case "explode":
+          c.log.add({
+            ...base(ev, ev.part),
+            type: "explode",
+            text: t("ev.explode", { where: where(ev.object, ev.part), energy: num(ev.energy, 0), radius: num(ev.radius, 1) }),
+            data: { energy: ev.energy, radius: ev.radius, point: ev.point }
+          });
+          break;
+        case "destroyed":
+          c.log.add({ channel: "event", type: "destroyed", objectId: ev.object, itemId: c.itemIdOf(ev.object), text: t("ev.destroyed", { obj: c.nameOf(ev.object) }) });
+          break;
+        default: {
+          const x = ev;
+          if (x.type === "stress") {
+            const part = String(x.part ?? "");
+            stressAt.set(`${x.object}|${part}`, now);
+            c.log.coalesce(
+              `stress:${x.object}:${part}`,
+              {
+                ...base(ev, part),
+                type: "stress",
+                text: t("ev.stress", { where: where(x.object, part), stress: num(Number(x.stress ?? 0) * 100, 0), load: num(Number(x.load ?? 0), 0) }),
+                data: { stress: x.stress, load: x.load }
+              },
+              1
+            );
+          } else if (x.type === "collapse") {
+            const parts = Array.isArray(x.parts) ? x.parts.map(String) : [];
+            c.log.add({
+              channel: "event",
+              type: "collapse",
+              objectId: x.object,
+              itemId: c.itemIdOf(x.object),
+              text: t("ev.collapse", { obj: c.nameOf(x.object), pieces: pieces(parts.length), mass: num(Number(x.mass ?? 0), 0), parts: list(parts) }),
+              data: { parts: parts.length, partIds: parts, massKg: x.mass, cause: x.cause }
+            });
+          }
+        }
+      }
+    }
+    for (const [k, d] of damage) {
+      if (SKIP_DAMAGE.has(d.type) || d.amount < 0.5) continue;
+      const [obj, part] = k.split("|");
+      const overload = d.type === "blunt" && now - (stressAt.get(k) ?? -99) <= 3;
+      const entry = {
+        channel: "event",
+        type: "damage",
+        objectId: obj,
+        itemId: c.itemIdOf(obj),
+        part,
+        material: findPart(obj, part)?.material ?? materialMemo.get(k),
+        state: stateOf(obj, part)
+      };
+      if (!overload) {
+        c.log.add({ ...entry, text: t("ev.damage", { where: where(obj, part), type: t(`dmg.${d.type}`), amount: num(d.amount, 0), hp: hpText(obj, part) }), data: { amount: d.amount, damageType: d.type } });
+        continue;
+      }
+      const acc = damageAcc.get(k);
+      const total = acc && now - acc.last <= 1 ? acc.total + d.amount : d.amount;
+      damageAcc.set(k, { total, last: now });
+      c.log.coalesce(
+        `damage:${k}`,
+        { ...entry, text: t("ev.damage.overload", { where: where(obj, part), amount: num(total, 0), hp: hpText(obj, part) }), data: { amount: total, damageType: d.type, overload: true } },
+        1
+      );
+    }
+  };
+  const kindMemo = /* @__PURE__ */ new Map();
+  const kindOf = (objectId, jointId) => {
+    const key = `${objectId}|${jointId}`;
+    const own = c.world.state(objectId)?.joints.find((j) => j.id === jointId)?.kind;
+    if (own) {
+      kindMemo.set(key, own);
+      return own;
+    }
+    const known = kindMemo.get(key);
+    if (known) return known;
+    for (const id of c.world.ids()) {
+      const k = c.world.state(id)?.joints.find((j) => j.id === jointId)?.kind;
+      if (k) return k;
+    }
+    return "";
+  };
+  const stainInfo = /* @__PURE__ */ new Map();
+  const stainAcc = /* @__PURE__ */ new Map();
+  const driedAcc = /* @__PURE__ */ new Map();
+  const drinkAcc = /* @__PURE__ */ new Map();
+  const fluid = (ev) => {
+    const who = (id) => c.containerName(id)?.name ?? id;
+    const meta = (id) => {
+      const m = c.containerName(id);
+      return { objectId: m?.objectId, itemId: m?.itemId };
+    };
+    const f = "fluid.";
+    switch (ev.type) {
+      case "fill":
+        c.log.coalesce(`fill:${ev.container}`, { channel: "event", type: f + "fill", ...meta(ev.container), text: t("fl.fill", { who: who(ev.container), liquid: c.liquidName(ev.liquid), liters: num(ev.liters, 2) }), data: { liters: ev.liters } }, 1.5);
+        break;
+      case "pour":
+        c.log.coalesce(`pour:${ev.container}`, { channel: "event", type: f + "pour", ...meta(ev.container), text: t("fl.pour", { who: who(ev.container), liquid: c.liquidName(ev.liquid), rate: num(ev.rate, 2) }), data: { rate: ev.rate } }, 2);
+        break;
+      case "spill":
+        c.log.coalesce(`spill:${ev.container}`, { channel: "event", type: f + "spill", ...meta(ev.container), text: t("fl.spill", { who: who(ev.container), liquid: c.liquidName(ev.liquid), rate: num(ev.rate, 2) }), data: { rate: ev.rate } }, 2);
+        break;
+      case "leak": {
+        const owner = meta(ev.container).objectId;
+        if (owner && c.now() - (leakAt.get(owner) ?? -99) <= 2) break;
+        c.log.coalesce(`fleak:${ev.container}`, { channel: "event", type: f + "leak", ...meta(ev.container), text: t("fl.leak", { who: who(ev.container), liquid: c.liquidName(ev.liquid), rate: num(ev.rate, ev.rate < 0.01 ? 3 : 2) }), data: { rate: ev.rate, point: ev.point } }, 2);
+        break;
+      }
+      case "drink": {
+        const now = c.now();
+        let acc = drinkAcc.get(ev.container);
+        if (!acc || now - acc.last > 0.5) acc = { liters: 0, thirst: 0, burn: false, effects: /* @__PURE__ */ new Set(), last: now, start: now };
+        acc.liters += ev.liters;
+        acc.thirst += ev.thirst;
+        acc.burn = acc.burn || ev.burn;
+        for (const e of ev.effects) acc.effects.add(e);
+        acc.last = now;
+        drinkAcc.set(ev.container, acc);
+        const effects = [...acc.effects].map((e) => t(`effect.${e}`)).join(", ");
+        c.log.coalesce(
+          `drink:${ev.container}:${acc.start}`,
+          {
+            channel: "event",
+            type: f + "drink",
+            ...meta(ev.container),
+            text: t("fl.drink", { who: who(ev.container), liters: num(acc.liters, 2), thirst: num(acc.thirst, 0) }) + (effects ? `, ${effects}` : "") + (acc.burn ? `, ${t("fl.burn")}` : ""),
+            data: { liters: acc.liters, temperature: ev.temperature, thirst: acc.thirst, effects: [...acc.effects], burn: acc.burn }
+          },
+          0.5
+        );
+        break;
+      }
+      case "empty":
+        c.log.add({ channel: "event", type: f + "empty", ...meta(ev.container), text: t("fl.empty", { who: who(ev.container) }) });
+        break;
+      case "splash":
+        c.log.coalesce(`splash:${ev.liquid}`, { channel: "event", type: f + "splash", text: t("fl.splash", { liquid: c.liquidName(ev.liquid) }), data: { point: ev.point, intensity: ev.intensity } }, 1);
+        break;
+      case "stain": {
+        const surface = t(`surface.${ev.surface}`);
+        const liquid = c.liquidName(ev.liquid);
+        stainInfo.set(ev.stain, { liquid: ev.liquid, surface, x: ev.point[0], z: ev.point[2] });
+        const key = `stain:${ev.liquid}:${ev.surface}`;
+        const acc = stainAcc.get(key);
+        const n = acc && c.now() - acc.last <= 1 ? acc.n + 1 : 1;
+        stainAcc.set(key, { n, last: c.now() });
+        c.log.coalesce(
+          key,
+          {
+            channel: "event",
+            type: f + "stain",
+            text: n > 1 ? t("fl.stains", { n, liquid, surface, where: xz(ev.point[0], ev.point[2]) }) : t("fl.stain", { liquid, surface, where: xz(ev.point[0], ev.point[2]) }),
+            data: { stain: ev.stain, surface: ev.surface, liquid: ev.liquid, point: ev.point, count: n }
+          },
+          1
+        );
+        break;
+      }
+      case "dried": {
+        const info = stainInfo.get(ev.stain);
+        const key = `dried:${info?.liquid ?? "?"}:${ev.mark}`;
+        const acc = driedAcc.get(key);
+        const n = acc && c.now() - acc.last <= 1.5 ? acc.n + 1 : 1;
+        driedAcc.set(key, { n, last: c.now() });
+        const vars = { liquid: info ? c.liquidName(info.liquid) : "", surface: info?.surface ?? "", where: info ? xz(info.x, info.z) : "", n };
+        const text = !info ? t(ev.mark ? "fl.dried.mark" : "fl.dried") : n > 1 ? t(ev.mark ? "fl.dried.many.mark" : "fl.dried.many", vars) : t(ev.mark ? "fl.dried.known.mark" : "fl.dried.known", vars);
+        c.log.coalesce(key, { channel: "event", type: f + "dried", text, data: { stain: ev.stain, mark: ev.mark, count: n } }, 1.5);
+        break;
+      }
+      case "mix":
+        c.log.add({ channel: "event", type: f + "mix", ...meta(ev.container), text: t("fl.mix", { who: who(ev.container), from: c.liquidName(ev.from), into: c.liquidName(ev.into) }) });
+        break;
+      default:
+        break;
+    }
+  };
+  return { events, fluid };
+}
+
+// src/player.ts
+var EYE = 1.7;
+var RADIUS = 0.3;
+var WALK = 3.4;
+var RUN = 6.2;
+var JUMP = 4.6;
+var GRAVITY = 13;
+var LOOK = 22e-4;
+function createPlayer(THREE, o) {
+  const cam = o.camera;
+  let yaw = 0;
+  let pitch = 0;
+  let y = 0;
+  let eye = EYE;
+  let vy = 0;
+  const px = { x: o.start[0], z: o.start[2] };
+  let locked = false;
+  const keys = /* @__PURE__ */ new Set();
+  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.updateMatrixWorld(true);
+  };
+  apply();
+  const blocked = (x, z) => {
+    if (Math.abs(x) > o.limit - RADIUS || Math.abs(z) > o.limit - RADIUS) return true;
+    for (const c of o.colliders) if (x > c[0] - RADIUS && x < c[2] + RADIUS && z > c[1] - RADIUS && z < c[3] + RADIUS) return true;
+    return false;
+  };
+  const move = (dx, dz) => {
+    if (!blocked(px.x + dx, px.z)) px.x += dx;
+    if (!blocked(px.x, px.z + dz)) px.z += dz;
+  };
+  let dragging = false;
+  let moved = 0;
+  let downAt = 0;
+  let useStarted = false;
+  let holdTimer = null;
+  const look = (dx, dy) => {
+    yaw -= dx * LOOK;
+    pitch = Math.max(-1.5, Math.min(1.5, pitch - dy * LOOK));
+  };
+  const onLockChange = () => {
+    locked = document.pointerLockElement === o.dom;
+  };
+  const onMouseDown = (e) => {
+    o.dom.focus?.();
+    if (e.button === 2) {
+      e.preventDefault();
+      o.hooks.secondary();
+      return;
+    }
+    if (e.button !== 0) return;
+    if (!locked) {
+      try {
+        const r = o.dom.requestPointerLock?.call(o.dom);
+        if (r && typeof r.catch === "function") r.catch(() => void 0);
+      } catch {
+      }
+      dragging = true;
+      moved = 0;
+      downAt = performance.now();
+      useStarted = false;
+      holdTimer = setTimeout(() => {
+        if (dragging && moved < 4 && !useStarted) {
+          useStarted = true;
+          o.hooks.primaryDown();
+        }
+      }, 220);
+      return;
+    }
+    useStarted = true;
+    o.hooks.primaryDown();
+  };
+  const onMouseUp = (e) => {
+    if (e.button !== 0) return;
+    if (holdTimer) clearTimeout(holdTimer);
+    if (dragging) {
+      dragging = false;
+      if (!useStarted && moved < 4 && performance.now() - downAt < 400) {
+        o.hooks.primaryDown();
+        o.hooks.primaryUp();
+      } else if (useStarted) o.hooks.primaryUp();
+      useStarted = false;
+      return;
+    }
+    if (useStarted) o.hooks.primaryUp();
+    useStarted = false;
+  };
+  const onMouseMove = (e) => {
+    if (locked) look(e.movementX, e.movementY);
+    else if (dragging) {
+      moved += Math.abs(e.movementX) + Math.abs(e.movementY);
+      if (moved >= 4) {
+        if (useStarted) {
+          useStarted = false;
+          o.hooks.primaryUp();
+        }
+        look(e.movementX, e.movementY);
+      }
+    }
+  };
+  const onWheel = (e) => {
+    e.preventDefault();
+    o.hooks.wheel(e.deltaY > 0 ? 1 : -1);
+  };
+  const typing = (e) => {
+    const t = e.target;
+    return !!t && (t.tagName === "INPUT" || t.tagName === "SELECT" || t.tagName === "TEXTAREA");
+  };
+  const onKeyDown = (e) => {
+    if (typing(e)) return;
+    if (e.code === "Space" || e.code === "Tab") e.preventDefault();
+    if (!e.repeat) keys.add(e.code);
+    o.hooks.key(e.code, true, e);
+  };
+  const onKeyUp = (e) => {
+    keys.delete(e.code);
+    if (typing(e)) return;
+    o.hooks.key(e.code, false, e);
+  };
+  const onContext = (e) => e.preventDefault();
+  const onBlur = () => keys.clear();
+  o.dom.addEventListener("mousedown", onMouseDown);
+  window.addEventListener("mouseup", onMouseUp);
+  window.addEventListener("mousemove", onMouseMove);
+  o.dom.addEventListener("wheel", onWheel, { passive: false });
+  o.dom.addEventListener("contextmenu", onContext);
+  document.addEventListener("pointerlockchange", onLockChange);
+  window.addEventListener("keydown", onKeyDown);
+  window.addEventListener("keyup", onKeyUp);
+  window.addEventListener("blur", onBlur);
+  return {
+    get yaw() {
+      return yaw;
+    },
+    get pitch() {
+      return pitch;
+    },
+    get locked() {
+      return locked;
+    },
+    keys,
+    update(dt) {
+      const run = keys.has("ShiftLeft") || keys.has("ShiftRight");
+      const speed = run ? RUN : WALK;
+      let f = 0;
+      let r = 0;
+      if (keys.has("KeyW") || keys.has("ArrowUp")) f += 1;
+      if (keys.has("KeyS") || keys.has("ArrowDown")) f -= 1;
+      if (keys.has("KeyD") || keys.has("ArrowRight")) r += 1;
+      if (keys.has("KeyA") || keys.has("ArrowLeft")) r -= 1;
+      if ((f || r || keys.has("Space")) && eye !== EYE) eye = EYE;
+      if (f || r) {
+        const len = Math.hypot(f, r);
+        const fx = -Math.sin(yaw);
+        const fz = -Math.cos(yaw);
+        const rx = Math.cos(yaw);
+        const rz = -Math.sin(yaw);
+        move((fx * f + rx * r) / len * speed * dt, (fz * f + rz * r) / len * speed * dt);
+      }
+      if (y <= 0 && keys.has("Space")) vy = JUMP;
+      if (y > 0 || vy > 0) {
+        vy -= GRAVITY * dt;
+        y += vy * dt;
+        if (y <= 0) {
+          y = 0;
+          vy = 0;
+        }
+      }
+      apply();
+    },
+    setPose(position, yw, pt) {
+      px.x = position[0];
+      px.z = position[2];
+      eye = position[1];
+      y = 0;
+      vy = 0;
+      yaw = yw;
+      pitch = pt;
+      apply();
+    },
+    look(position, target) {
+      px.x = position[0];
+      px.z = position[2];
+      eye = position[1];
+      y = 0;
+      vy = 0;
+      const dx = target[0] - position[0];
+      const dy = target[1] - position[1];
+      const dz = target[2] - position[2];
+      yaw = Math.atan2(-dx, -dz);
+      pitch = Math.atan2(dy, Math.hypot(dx, dz));
+      apply();
+    },
+    kick(pitchDeg, yawDeg) {
+      pitch = Math.max(-1.5, Math.min(1.5, pitch + pitchDeg * Math.PI / 180));
+      yaw += yawDeg * Math.PI / 180;
+      apply();
+    },
+    walk(forward, right) {
+      move(-Math.sin(yaw) * forward + Math.cos(yaw) * right, -Math.cos(yaw) * forward - Math.sin(yaw) * right);
+      apply();
+    },
+    dispose() {
+      if (holdTimer) clearTimeout(holdTimer);
+      o.dom.removeEventListener("mousedown", onMouseDown);
+      window.removeEventListener("mouseup", onMouseUp);
+      window.removeEventListener("mousemove", onMouseMove);
+      o.dom.removeEventListener("wheel", onWheel);
+      o.dom.removeEventListener("contextmenu", onContext);
+      document.removeEventListener("pointerlockchange", onLockChange);
+      window.removeEventListener("keydown", onKeyDown);
+      window.removeEventListener("keyup", onKeyUp);
+      window.removeEventListener("blur", onBlur);
+      if (document.pointerLockElement === o.dom) document.exitPointerLock?.();
+    }
+  };
+}
+
+// src/scenarios.ts
+import { JOINT_DEFAULTS } 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");
+      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");
+      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");
+      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");
+      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" && 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");
+      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("screwdriver_shelf_board", ({ room, step, expect }) => {
+      const id = at(room, "shelf", 0, -4);
+      room.setTool("screwdriver");
+      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");
+      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");
+      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");
+      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");
+      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");
+      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");
+      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");
+      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");
+      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) });
+    })
+  ];
+}
+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;
+};
+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");
+
+// src/ui.ts
+var CSS = `
+.tr-root{position:absolute;inset:0;pointer-events:none;font:12px/1.35 system-ui,-apple-system,"Segoe UI",Roboto,sans-serif;color:#e8eaee;overflow:hidden}
+.tr-root *{box-sizing:border-box}
+.tr-root button,.tr-root select,.tr-root label{pointer-events:auto}
+.tr-cross{position:absolute;left:50%;top:50%;width:18px;height:18px;margin:-9px 0 0 -9px}
+.tr-cross:before,.tr-cross:after{content:"";position:absolute;background:#fff;opacity:.85;box-shadow:0 0 2px #000}
+.tr-cross:before{left:8px;top:0;width:2px;height:18px}.tr-cross:after{top:8px;left:0;height:2px;width:18px}
+.tr-cross i{position:absolute;left:6px;top:6px;width:6px;height:6px;background:#0b0c0e;border-radius:50%;z-index:1}
+.tr-top{position:absolute;top:8px;left:50%;transform:translateX(-50%);text-align:center;max-width:46vw}
+.tr-tool{display:inline-block;background:rgba(10,12,16,.72);padding:4px 12px;border-radius:6px;font-size:14px;font-weight:600}
+.tr-tool small{font-weight:400;opacity:.8;margin-left:8px}
+.tr-status{margin-top:4px;min-height:16px;color:#ffd23f;text-shadow:0 1px 2px #000}
+.tr-prog{margin:4px auto 0;width:260px;background:rgba(10,12,16,.72);border-radius:6px;padding:4px 8px;display:none}
+.tr-prog b{display:block;font-weight:500;margin-bottom:3px}
+.tr-bar{height:7px;background:#2a2e36;border-radius:4px;overflow:hidden}
+.tr-bar i{display:block;height:100%;background:#4fc3f7;width:0}
+.tr-bar.hp i{background:#66bb6a}.tr-bar.warn i{background:#ffb300}.tr-bar.bad i{background:#ef5350}
+.tr-bottom{position:absolute;bottom:8px;left:50%;transform:translateX(-50%);text-align:center;max-width:56vw}
+.tr-held{margin-bottom:6px;background:rgba(10,12,16,.72);padding:4px 10px;border-radius:6px;display:none}
+.tr-held kbd,.tr-help kbd{background:#2a2e36;border:1px solid #4a505c;border-radius:3px;padding:0 4px;font:inherit;font-weight:700}
+.tr-hotbar{display:inline-flex;gap:3px;flex-wrap:wrap;justify-content:center}
+.tr-slot{pointer-events:auto;min-width:64px;max-width:92px;padding:3px 5px;background:rgba(10,12,16,.68);border:1px solid #3a404c;border-radius:5px;color:#cfd3da;cursor:pointer;font-size:11px;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
+.tr-slot b{color:#ffd23f;margin-right:3px}
+.tr-slot.on{border-color:#ffd23f;color:#fff;background:rgba(60,50,10,.8)}
+.tr-help{position:absolute;left:8px;bottom:8px;max-width:360px;opacity:.75;font-size:11px;background:rgba(10,12,16,.55);padding:4px 8px;border-radius:6px}
+.tr-left{position:absolute;top:8px;left:8px;bottom:70px;width:min(400px,36vw);display:flex;flex-direction:column;gap:8px}
+.tr-right{position:absolute;top:8px;right:8px;bottom:8px;width:min(310px,34vw);display:flex;flex-direction:column;gap:8px}
+.tr-panel{background:rgba(12,14,19,.82);border:1px solid #2c313b;border-radius:8px;padding:8px;pointer-events:auto;overflow:auto}
+.tr-panel h3{margin:0 0 6px;font-size:12px;letter-spacing:.04em;text-transform:uppercase;color:#9aa3b2;font-weight:600}
+.tr-insp{flex:0 0 auto;max-height:46%;min-height:60px}
+.tr-insp .r{display:flex;justify-content:space-between;gap:8px}.tr-insp .r span:first-child{color:#9aa3b2}
+.tr-insp .t{font-weight:600;font-size:13px;margin-bottom:3px}
+.tr-log{flex:1 1 auto;display:flex;flex-direction:column;min-height:120px;overflow:hidden}
+.tr-logbar{display:flex;flex-wrap:wrap;gap:4px;margin-bottom:5px;align-items:center}
+.tr-logbody{flex:1;overflow:auto;font:11px/1.4 ui-monospace,SFMono-Regular,Menlo,monospace;background:#090a0d;border-radius:5px;padding:4px 6px}
+.tr-logbody div{white-space:pre-wrap;word-break:break-word;border-bottom:1px solid #15171c}
+.tr-logbody .action{color:#8fd3ff}.tr-logbody .event{color:#dfe3ea}.tr-logbody .check{color:#c8e6c9}.tr-logbody .check.fail{color:#ff8a80;font-weight:700}.tr-logbody .check.pass{color:#9be59f}
+.tr-logbody time{color:#6b7280;margin-right:6px}
+.tr-btn,.tr-root button.tr-btn{background:#232831;border:1px solid #3a404c;color:#e8eaee;border-radius:5px;padding:3px 8px;cursor:pointer;font:inherit}
+.tr-btn:hover{background:#2d3440}.tr-btn.on{background:#3b3a14;border-color:#ffd23f;color:#fff}
+.tr-btn.pass{border-color:#4caf50}.tr-btn.fail{border-color:#ef5350;background:#3a1d1d}
+.tr-tabs{display:flex;flex-wrap:wrap;gap:3px;margin-bottom:6px}
+.tr-items{display:grid;grid-template-columns:1fr 1fr;gap:4px}
+.tr-item{display:flex;gap:2px}.tr-item .tr-btn:first-child{flex:1;text-align:left;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
+.tr-cat{flex:0 1 auto;max-height:40%}
+.tr-anim{flex:0 0 auto;max-height:18%}
+.tr-anim .list{display:flex;flex-wrap:wrap;gap:4px}.tr-anim .sub{color:#9aa3b2;margin-bottom:4px}
+.tr-tests{flex:1 1 auto;min-height:100px}
+.tr-tests .list{display:flex;flex-direction:column;gap:3px;margin-top:6px}.tr-tests .list .tr-btn{text-align:left}
+.tr-row{display:flex;flex-wrap:wrap;gap:4px;margin-top:6px;align-items:center}
+.tr-toggle{position:absolute;top:8px;right:8px;display:none}
+.tr-summary{margin-top:6px;color:#9aa3b2}
+@media (max-width:980px){.tr-left,.tr-right{display:none}.tr-root.open .tr-left,.tr-root.open .tr-right{display:flex}.tr-toggle{display:block;pointer-events:auto}.tr-root.open .tr-toggle{right:min(310px,34vw)}.tr-left{width:min(400px,46vw)}.tr-help{display:none}}
+`;
+var mk = (tag, cls, text) => {
+  const e = document.createElement(tag);
+  if (cls) e.className = cls;
+  if (text !== void 0) e.textContent = text;
+  return e;
+};
+function createUi(o) {
+  const { t } = o;
+  const style = mk("style");
+  style.textContent = CSS;
+  const root = mk("div", "tr-root");
+  const pos = getComputedStyle?.(o.container)?.position;
+  if (!pos || pos === "static") o.container.style.position = "relative";
+  root.appendChild(style);
+  o.container.appendChild(root);
+  const cross = mk("div", "tr-cross");
+  cross.appendChild(mk("i"));
+  const top = mk("div", "tr-top");
+  const toolBox = mk("div", "tr-tool");
+  const status = mk("div", "tr-status");
+  const prog = mk("div", "tr-prog");
+  const progLabel = mk("b");
+  const progBar = mk("div", "tr-bar");
+  const progFill = mk("i");
+  progBar.appendChild(progFill);
+  prog.append(progLabel, progBar);
+  top.append(toolBox, status, prog);
+  const bottom = mk("div", "tr-bottom");
+  const held = mk("div", "tr-held");
+  const hotbar = mk("div", "tr-hotbar");
+  bottom.append(held, hotbar);
+  const help = mk("div", "tr-help");
+  help.textContent = t("ui.help");
+  const left = mk("div", "tr-left");
+  const insp = mk("div", "tr-panel tr-insp");
+  const logPanel = mk("div", "tr-panel tr-log");
+  left.append(insp, logPanel);
+  const logTitle = mk("h3", void 0, t("ui.log"));
+  const logBar = mk("div", "tr-logbar");
+  const logBody = mk("div", "tr-logbody");
+  const filters = { action: true, event: true, check: true };
+  const filterBtns = [];
+  for (const ch of ["action", "event", "check"]) {
+    const b = mk("button", "tr-btn on", t(`ui.filter.${ch}`));
+    b.type = "button";
+    b.onclick = () => {
+      filters[ch] = !filters[ch];
+      b.classList.toggle("on", filters[ch]);
+      rebuildLog();
+    };
+    filterBtns.push(b);
+    logBar.appendChild(b);
+  }
+  let autoscroll = true;
+  const asLabel = mk("label");
+  const asBox = mk("input");
+  asBox.type = "checkbox";
+  asBox.checked = true;
+  asBox.onchange = () => {
+    autoscroll = asBox.checked;
+  };
+  asLabel.append(asBox, document.createTextNode(" " + t("ui.autoscroll")));
+  logBar.appendChild(asLabel);
+  const logBtn = (label, fn) => {
+    const b = mk("button", "tr-btn", label);
+    b.type = "button";
+    b.onclick = fn;
+    logBar.appendChild(b);
+  };
+  logBtn(t("ui.copy_json"), () => {
+    const text = o.log.toJSON();
+    try {
+      void navigator.clipboard.writeText(text);
+    } catch {
+      const ta = mk("textarea");
+      ta.value = text;
+      document.body.appendChild(ta);
+      ta.select();
+      document.execCommand?.("copy");
+      ta.remove();
+    }
+  });
+  logBtn(t("ui.download_ndjson"), () => o.log.download("ndjson"));
+  logBtn(t("ui.download_txt"), () => o.log.download("txt"));
+  logBtn(t("ui.clear_log"), () => {
+    o.log.clear();
+    logBody.textContent = "";
+    nodes.clear();
+  });
+  logPanel.append(logTitle, logBar, logBody);
+  const MAX_LINES = 200;
+  const nodes = /* @__PURE__ */ new Map();
+  const fmtTime = (s) => `${Math.floor(s / 60).toString().padStart(2, "0")}:${(s % 60).toFixed(1).padStart(4, "0")}`;
+  const lineClass = (e) => `${e.channel}${e.type === "fail" || e.type === "scenario_fail" ? " fail" : e.type === "pass" || e.type === "scenario_pass" ? " pass" : ""}`;
+  const fill = (n, e) => {
+    n.className = lineClass(e);
+    n.textContent = "";
+    const tm = mk("time", void 0, fmtTime(e.t));
+    n.append(tm, document.createTextNode(e.text));
+  };
+  const addNode = (e) => {
+    if (!filters[e.channel]) return;
+    const n = mk("div");
+    fill(n, e);
+    nodes.set(e.seq, n);
+    logBody.appendChild(n);
+    while (logBody.childElementCount > MAX_LINES) {
+      const first = logBody.firstElementChild;
+      for (const [k, v] of nodes) if (v === first) nodes.delete(k);
+      first.remove();
+    }
+    if (autoscroll) logBody.scrollTop = logBody.scrollHeight;
+  };
+  function rebuildLog() {
+    logBody.textContent = "";
+    nodes.clear();
+    for (const e of o.log.entries().slice(-MAX_LINES * 3)) addNode(e);
+  }
+  const offLog = o.log.on((e, updated) => {
+    if (updated) {
+      const n = nodes.get(e.seq);
+      if (n) fill(n, e);
+    } else addNode(e);
+  });
+  const right = mk("div", "tr-right");
+  const cat = mk("div", "tr-panel tr-cat");
+  const anim = mk("div", "tr-panel tr-anim");
+  const tests = mk("div", "tr-panel tr-tests");
+  right.append(cat, anim, tests);
+  cat.appendChild(mk("h3", void 0, t("ui.catalog")));
+  const tabs = mk("div", "tr-tabs");
+  const items = mk("div", "tr-items");
+  cat.append(tabs, items);
+  let activeGroup = "";
+  const renderItems = () => {
+    items.textContent = "";
+    for (const it of o.groups().get(activeGroup) ?? []) {
+      const wrap = mk("div", "tr-item");
+      const b = mk("button", "tr-btn", it.name);
+      b.type = "button";
+      b.title = it.note ?? it.name;
+      b.onclick = () => o.onSpawn(it.id);
+      wrap.appendChild(b);
+      if (it.weapon) {
+        const w = mk("button", "tr-btn", "\u2694");
+        w.type = "button";
+        w.title = t("ui.equip");
+        w.onclick = () => o.onEquip(it.id);
+        wrap.appendChild(w);
+      }
+      items.appendChild(wrap);
+    }
+  };
+  const renderTabs = () => {
+    tabs.textContent = "";
+    const groupNames = [...o.groups().keys()];
+    if (!groupNames.includes(activeGroup)) activeGroup = groupNames[0] ?? "";
+    for (const g of groupNames) {
+      const b = mk("button", g === activeGroup ? "tr-btn on" : "tr-btn", g);
+      b.type = "button";
+      b.onclick = () => {
+        activeGroup = g;
+        renderTabs();
+      };
+      tabs.appendChild(b);
+    }
+    renderItems();
+  };
+  renderTabs();
+  const controls = mk("div", "tr-row");
+  const ctl = (label, fn) => {
+    const b = mk("button", "tr-btn", label);
+    b.type = "button";
+    b.onclick = () => fn(b);
+    controls.appendChild(b);
+    return b;
+  };
+  ctl(t("ui.clear"), () => o.onClear());
+  ctl(t("ui.reset_all"), () => o.onResetAll());
+  let slow = false;
+  ctl(t("ui.slow"), (b) => {
+    slow = !slow;
+    b.classList.toggle("on", slow);
+    o.onSlow(slow);
+  });
+  let fast = false;
+  ctl(t("ui.fast"), (b) => {
+    fast = !fast;
+    b.classList.toggle("on", fast);
+    o.onFast(fast);
+  });
+  const tapBtn = ctl(t("ui.tap"), () => o.onTap());
+  const qSel = mk("select");
+  for (const q of ["low", "medium", "high"]) {
+    const op = mk("option", void 0, t(`ui.quality.${q}`));
+    op.value = q;
+    qSel.appendChild(op);
+  }
+  qSel.value = o.quality;
+  qSel.onchange = () => o.onQuality(qSel.value);
+  const qLabel = mk("label", void 0, t("ui.quality") + " ");
+  qLabel.appendChild(qSel);
+  controls.appendChild(qLabel);
+  const count = mk("span");
+  controls.appendChild(count);
+  cat.appendChild(controls);
+  tests.appendChild(mk("h3", void 0, t("ui.tests")));
+  const runAll = mk("button", "tr-btn", t("ui.run_all"));
+  runAll.type = "button";
+  const summary = mk("div", "tr-summary");
+  const list = mk("div", "list");
+  tests.append(runAll, summary, list);
+  const scBtns = /* @__PURE__ */ new Map();
+  let busy = false;
+  const mark = (rep) => {
+    if (!rep) return;
+    for (const r of rep.results) {
+      const b = scBtns.get(r.id);
+      if (!b) continue;
+      b.classList.remove("pass", "fail");
+      b.classList.add(r.ok ? "pass" : "fail");
+      b.textContent = `${r.ok ? "\u2713" : "\u2717"} ${r.name}`;
+    }
+    summary.textContent = t("ui.report", { passed: rep.passed, failed: rep.failed });
+  };
+  const renderScenarios = () => {
+    list.textContent = "";
+    scBtns.clear();
+    for (const s of o.scenarios()) {
+      const b = mk("button", "tr-btn", s.name);
+      b.type = "button";
+      b.onclick = async () => {
+        if (busy) return;
+        busy = true;
+        try {
+          mark(await o.onRun(s));
+        } finally {
+          busy = false;
+        }
+      };
+      scBtns.set(s.id, b);
+      list.appendChild(b);
+    }
+  };
+  renderScenarios();
+  runAll.onclick = async () => {
+    if (busy) return;
+    busy = true;
+    summary.textContent = t("ui.running");
+    try {
+      mark(await o.onRunAll());
+    } finally {
+      busy = false;
+    }
+  };
+  const toggle = mk("button", "tr-btn tr-toggle", t("ui.panel"));
+  toggle.type = "button";
+  const togglePanels = () => {
+    root.classList.toggle("open");
+    o.onResize();
+  };
+  toggle.onclick = togglePanels;
+  root.append(cross, top, bottom, help, left, right, toggle);
+  const bar = (value, max, cls) => {
+    const b = mk("div", `tr-bar ${cls}`);
+    const i = mk("i");
+    i.style.width = `${Math.max(0, Math.min(100, value / Math.max(1e-9, max) * 100))}%`;
+    b.appendChild(i);
+    return b;
+  };
+  const row = (k, v) => {
+    const r = mk("div", "r");
+    r.append(mk("span", void 0, k), mk("span", void 0, v));
+    return r;
+  };
+  const num = (n, d = 1) => {
+    const s = (Math.round(n * 10 ** d) / 10 ** d).toFixed(d);
+    return t("locale.decimal") === "," ? s.replace(".", ",") : s;
+  };
+  const renderInspector = (i) => {
+    insp.textContent = "";
+    insp.appendChild(mk("h3", void 0, t("ui.inspector")));
+    if (!i) {
+      insp.appendChild(mk("div", void 0, t("ui.aim_at_something")));
+      return;
+    }
+    insp.appendChild(mk("div", "t", `${i.object} \u203A ${i.part}`));
+    insp.appendChild(row(t("ins.material"), i.material));
+    insp.appendChild(row(t("ins.status"), i.status + (i.burning ? ` \xB7 ${t("ins.burning")}` : "")));
+    insp.appendChild(row(t("ins.hp"), `${num(i.hp, 0)} / ${num(i.maxHp, 0)}`));
+    const frac = i.hp / Math.max(1e-9, i.maxHp);
+    insp.appendChild(bar(i.hp, i.maxHp, frac < 0.25 ? "bad" : frac < 0.6 ? "warn" : "hp"));
+    insp.appendChild(row(t("ins.temperature"), `${num(i.temperature, 0)} \xB0C`));
+    if (i.char > 0.01) insp.appendChild(row(t("ins.char"), `${num(i.char * 100, 0)} %`));
+    if (i.melt > 0.01) insp.appendChild(row(t("ins.melt"), `${num(i.melt * 100, 0)} %`));
+    if (i.liters !== void 0) insp.appendChild(row(t("ins.liters"), `${num(i.liters, 2)} l`));
+    const cn = (what, n) => t(`count.${what}.${n === 1 ? "one" : "other"}`, { n });
+    insp.appendChild(row(t("ins.damage"), t("ins.damage_counts", { dents: cn("dent", i.dents), holes: cn("hole", i.holes), cracks: cn("crack", i.cracks) })));
+    insp.appendChild(row(t("ins.mass"), `${num(i.mass, 1)} kg`));
+    if (i.load !== void 0) insp.appendChild(row(t("ins.load"), `${num(i.load, 0)} kg`));
+    if (i.stress !== void 0) {
+      insp.appendChild(row(t("ins.stress"), `${num(i.stress * 100, 0)} %`));
+      insp.appendChild(bar(Math.min(i.stress, 1.2), 1.2, i.stress > 1 ? "bad" : i.stress > 0.7 ? "warn" : "hp"));
+    }
+    if (i.joints.length) {
+      insp.appendChild(mk("div", void 0, t("ins.joints") + ":"));
+      for (const j of i.joints) {
+        const tools = j.tools.length ? j.tools.join(", ") : t("tool.none");
+        insp.appendChild(mk("div", void 0, `\u2022 ${j.kind} (${j.id})${j.open ? ` \xB7 ${t("ins.open")}` : ` \u2192 ${tools}`}`));
+      }
+    }
+    if (i.note) insp.appendChild(mk("div", void 0, i.note));
+  };
+  let lastAnim = "";
+  const renderAnimations = (a) => {
+    anim.textContent = "";
+    anim.appendChild(mk("h3", void 0, t("ui.animations")));
+    if (!a) {
+      anim.appendChild(mk("div", "sub", t("ui.animations_aim")));
+      return;
+    }
+    anim.appendChild(mk("div", "sub", a.name));
+    if (a.clips.length === 0) {
+      anim.appendChild(mk("div", "sub", t("ui.animations_none")));
+      return;
+    }
+    const l = mk("div", "list");
+    for (const c of a.clips) {
+      const b = mk("button", a.playing === c.id ? "tr-btn on" : "tr-btn", `\u25B6 ${t(`anim.${c.id}`) === `anim.${c.id}` ? c.id : t(`anim.${c.id}`)} (${num(c.duration, 1)} s)`);
+      b.type = "button";
+      b.onclick = () => o.onPlay(a.objectId, c.id);
+      l.appendChild(b);
+    }
+    anim.appendChild(l);
+  };
+  renderAnimations(null);
+  let toastTimer = null;
+  const slotsEl = [];
+  let lastSlotsKey = "";
+  let lastInspect = "";
+  let hudPage = 0;
+  const api = {
+    hud(s) {
+      toolBox.textContent = "";
+      toolBox.append(document.createTextNode(s.toolName));
+      if (s.ammo) toolBox.append(mk("small", void 0, s.ammo));
+      if (s.status) status.textContent = s.status;
+      else if (!toastTimer) status.textContent = "";
+      if (s.progress) {
+        prog.style.display = "block";
+        progLabel.textContent = s.progress.label;
+        progFill.style.width = `${Math.round(s.progress.value * 100)}%`;
+      } else prog.style.display = "none";
+      if (s.held) {
+        held.style.display = "block";
+        held.textContent = "";
+        held.append(document.createTextNode(`${s.held.name} \xB7 `));
+        const keys = [
+          ["E", t("hud.drop")],
+          ["R", t("hud.rotate")],
+          ["G", t("hud.throw")],
+          ["Z", t("hud.tilt")],
+          ...s.held.uses.map((u) => [u.key, u.label])
+        ];
+        if (s.held.weapon) keys.push(["H", t("hud.equip", { weapon: s.held.weapon })]);
+        for (const [k, label] of keys) {
+          held.append(mk("kbd", void 0, k), document.createTextNode(` ${label}  `));
+        }
+      } else held.style.display = "none";
+      const key = s.slots.join("|") + s.page;
+      if (key !== lastSlotsKey) {
+        lastSlotsKey = key;
+        hotbar.textContent = "";
+        slotsEl.length = 0;
+        hudPage = s.page - 1;
+        s.slots.forEach((name, i) => {
+          const b = mk("button", "tr-slot");
+          b.type = "button";
+          b.append(mk("b", void 0, String((i + 1) % 10)), document.createTextNode(name));
+          b.title = name;
+          b.onclick = () => o.onTool(hudPage * 10 + i);
+          hotbar.appendChild(b);
+          slotsEl.push(b);
+        });
+      }
+      slotsEl.forEach((b, i) => b.classList.toggle("on", i === s.slot));
+      tapBtn.classList.toggle("on", s.tap);
+      count.textContent = t("ui.objects", { n: s.objects });
+      const ak = JSON.stringify(s.animations);
+      if (ak !== lastAnim) {
+        lastAnim = ak;
+        renderAnimations(s.animations);
+      }
+      const ik = JSON.stringify(s.inspect);
+      if (ik !== lastInspect) {
+        lastInspect = ik;
+        renderInspector(s.inspect);
+      }
+    },
+    toast(text) {
+      status.textContent = text;
+      if (toastTimer) clearTimeout(toastTimer);
+      toastTimer = setTimeout(() => {
+        toastTimer = null;
+      }, 2e3);
+    },
+    refresh() {
+      renderTabs();
+      renderScenarios();
+    },
+    togglePanels,
+    dispose() {
+      offLog();
+      if (toastTimer) clearTimeout(toastTimer);
+      root.remove();
+    }
+  };
+  rebuildLog();
+  return api;
+}
+
+// src/room.ts
+var FIXED_DT = 1 / 60;
+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) {
+  const THREE = options.THREE;
+  const locale = options.locale ?? "en";
+  const S = resolveStrings(locale);
+  const dStrings = resolveDestructionStrings(locale);
+  const fStrings = resolveFluidStrings(locale);
+  const t = (key, vars) => {
+    let s = S.text[key] ?? key;
+    if (vars) for (const k of Object.keys(vars)) s = s.split(`{${k}}`).join(String(vars[k]));
+    return s;
+  };
+  const num = (n, digits = 1) => {
+    const s = (Math.round(n * 10 ** digits) / 10 ** digits).toFixed(digits);
+    return locale.toLowerCase().startsWith("pt") ? s.replace(".", ",") : s;
+  };
+  const ownRenderer = !options.renderer;
+  const gl = options.renderer ?? new THREE.WebGLRenderer({ antialias: true });
+  const container = options.container;
+  const width = () => container.clientWidth || 960;
+  const height = () => container.clientHeight || 600;
+  if (ownRenderer) {
+    const r = gl;
+    r.setPixelRatio(Math.min(typeof devicePixelRatio === "number" ? devicePixelRatio : 1, 2));
+    r.shadowMap.enabled = true;
+    r.shadowMap.type = THREE.PCFSoftShadowMap;
+    r.toneMapping = THREE.ACESFilmicToneMapping;
+    r.toneMappingExposure = 1;
+    r.outputColorSpace = THREE.SRGBColorSpace;
+    container.appendChild(r.domElement);
+  }
+  gl.setSize(width(), height());
+  const dom = gl.domElement;
+  if (dom && !dom.hasAttribute?.("tabindex")) dom.setAttribute?.("tabindex", "0");
+  const scene = options.scene ?? new THREE.Scene();
+  const camera = options.camera ?? new THREE.PerspectiveCamera(72, width() / height(), 0.05, 140);
+  if (!options.camera) scene.add(camera);
+  const resize = () => {
+    const w = width();
+    const h = height();
+    gl.setSize(w, h);
+    camera.aspect = w / h;
+    camera.updateProjectionMatrix();
+  };
+  const onResize = () => resize();
+  window.addEventListener("resize", onResize);
+  const arenaSize = options.arenaSize ?? 14;
+  const arena = createArena(THREE, arenaSize, scene);
+  scene.add(arena.group);
+  const ownWorld = !options.world;
+  const world = options.world ?? createDestruction({ seed: 1, ...options.worldOptions, materials: [...DEMO_MATERIALS, ...options.worldOptions?.materials ?? []] });
+  const pristineWorld = ownWorld ? world.serialize() : null;
+  const tableOk = () => {
+    const p = world.part(arena.table.id, arena.table.topPart);
+    return !!p && p.status !== "broken" && p.status !== "melted" && p.status !== "ashes";
+  };
+  const groundAt = (x, z) => x > arena.table.minX && x < arena.table.maxX && z > arena.table.minZ && z < arena.table.maxZ && tableOk() ? arena.table.top : 0;
+  const ownFluids = !options.fluids;
+  const fluids = options.fluids ?? createFluids({ seed: 1, locale, liquids: options.liquids, groundAt });
+  const pristineFluids = ownFluids ? fluids.serialize() : null;
+  for (const s of [...arena.surfaces, ...options.surfaces ?? []]) fluids.addSurface(s);
+  const itemUseDefs = [...ITEM_USES, ...options.itemUses ?? []];
+  const quality = options.quality ?? "medium";
+  const pointScale = height() / (2 * Math.tan(camera.fov * Math.PI / 360));
+  const rendererPieces = /* @__PURE__ */ new Map();
+  const entries = /* @__PURE__ */ new Map();
+  const splitOf = /* @__PURE__ */ new Map();
+  let simTime = 0;
+  const log = createLog();
+  log.setClock(() => simTime);
+  const renderer = createDestructionRenderer(THREE, {
+    scene,
+    world,
+    quality,
+    groundAt,
+    pointScale,
+    onSound: options.onSound,
+    onPiece: (piece) => {
+      rendererPieces.set(piece.objectId, piece);
+      loose.push(piece);
+      const st = world.state(piece.objectId);
+      if (!st) return;
+      let best = null;
+      let bestD = Infinity;
+      for (const e of entries.values()) {
+        const spec = specs.get(e.so.objectId);
+        if (!spec) continue;
+        const ids = new Set(spec.parts.map((p) => p.id));
+        if (!st.parts.every((p) => ids.has(p.id))) continue;
+        const d = e.so.root.position.distanceTo(piece.root.position);
+        if (d < bestD) {
+          bestD = d;
+          best = e;
+        }
+      }
+      if (best) splitOf.set(piece.objectId, best);
+    }
+  });
+  const fluidView = createFluidRenderer(THREE, { scene, fluids, quality, pointScale });
+  const specs = /* @__PURE__ */ new Map();
+  const loose = [];
+  const arsenal = options.arsenal ?? createArsenal({ locale, weapons: options.weapons, seed: 1 });
+  const loadout = (options.loadout ?? DEFAULT_LOADOUT).filter((id) => arsenal.weapons.has(id));
+  const tools = /* @__PURE__ */ new Map();
+  let toolIndex = Math.max(0, loadout.indexOf("hand"));
+  let toolId = loadout[toolIndex] ?? "hand";
+  const toolState = (id) => {
+    let s = tools.get(id);
+    if (!s) {
+      s = arsenal.create(id, { seed: 7, reserve: 999 });
+      s.refill();
+      tools.set(id, s);
+    }
+    return s;
+  };
+  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);
+  const nameOf = (objectId) => {
+    const e = entries.get(objectId);
+    if (e) return e.name;
+    const s = splitOf.get(objectId);
+    return s ? `${s.name} (${t("piece")})` : objectId;
+  };
+  const narrator = createNarrator({
+    world,
+    fluids,
+    log,
+    now: () => simTime,
+    t,
+    num,
+    nameOf,
+    itemIdOf: (id) => entryOf(id)?.so.itemId,
+    materialName: (id) => S.text[`material.${id}`] ?? dStrings.materialNames[id] ?? id,
+    liquidName: (id) => fStrings.liquids[id] ?? id,
+    jointKind: (k) => dStrings.jointKinds[k] ?? k,
+    toolName: (k) => dStrings.toolKinds[k] ?? k,
+    locatePart: (objectId, partId) => {
+      const own = world.part(objectId, partId);
+      if (own) return { objectId, part: own };
+      for (const [id, owner] of splitOf) {
+        if (owner.so.objectId !== objectId) continue;
+        const p = world.part(id, partId);
+        if (p) return { objectId: id, part: p };
+      }
+      return null;
+    },
+    containerName: (cid) => {
+      for (const e of entries.values()) if (e.containerId === cid) return { name: e.name, objectId: e.so.objectId, itemId: e.so.itemId };
+      return void 0;
+    }
+  });
+  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 fire = (type, data) => {
+    for (const fn of listeners[type] ?? []) fn(data);
+  };
+  world.on("*", (ev) => {
+    pending.push(ev);
+  });
+  fluids.on("*", (ev) => {
+    narrator.fluid(ev);
+    fire("event", ev);
+  });
+  const action = (type, text, extra = {}) => {
+    log.add({ channel: "action", type, text, ...extra });
+  };
+  const tmpV = new THREE.Vector3();
+  const tmpV2 = new THREE.Vector3();
+  const tmpQ = new THREE.Quaternion();
+  const tmpM = new THREE.Matrix4();
+  const hostOf = (e) => {
+    if (e.fluidPart && !e.arena && !world.part(e.so.objectId, e.fluidPart)) {
+      for (const [id, owner] of splitOf) {
+        if (owner === e && world.part(id, e.fluidPart)) {
+          const p = rendererPieces.get(id);
+          if (p) return { objectId: id, root: p.root };
+        }
+      }
+    }
+    return { objectId: e.so.objectId, root: e.so.root };
+  };
+  const puncture = (ev) => {
+    const e = entryOf(ev.object);
+    if (!e?.containerId || e.fluidPart !== ev.part) return;
+    const host = hostOf(e);
+    host.root.updateMatrixWorld(true);
+    tmpM.copy(host.root.matrixWorld).invert();
+    const local = tmpV.set(ev.point[0], ev.point[1], ev.point[2]).applyMatrix4(tmpM);
+    local.x -= e.fluidOffset[0];
+    local.y -= e.fluidOffset[1];
+    local.z -= e.fluidOffset[2];
+    host.root.getWorldQuaternion(tmpQ).invert();
+    const n = tmpV2.set(ev.direction[0], ev.direction[1], ev.direction[2]).applyQuaternion(tmpQ);
+    const part = world.part(host.objectId, ev.part);
+    const hole = part?.holes[part.holes.length - 1];
+    fluids.puncture(e.containerId, [local.x, local.y, local.z], [n.x, n.y, n.z], hole?.diameter ?? 9e-3);
+  };
+  const flush = () => {
+    if (pending.length === 0) return;
+    const batch = pending;
+    pending = [];
+    narrator.events(batch);
+    for (const ev of batch) {
+      if (ev.type === "leak") puncture(ev);
+      else if (ev.type === "ignite") igniteNear(ev.point, 0.9);
+      fire("event", ev);
+      options.onEvent?.(ev);
+    }
+  };
+  log.setBeforeRead(flush);
+  let useHeld = false;
+  let useFirst = false;
+  const player = createPlayer(THREE, {
+    camera,
+    dom,
+    colliders: arena.colliders,
+    limit: arenaSize,
+    start: arena.playerStart,
+    hooks: {
+      primaryDown: () => {
+        useHeld = true;
+        useFirst = true;
+      },
+      primaryUp: () => {
+        useHeld = false;
+        tool.release();
+      },
+      secondary: () => {
+        if (heldEntry) throwHeld();
+        else grab();
+      },
+      key: (code, down, e) => onKey(code, down, e),
+      wheel: (dir) => cycleTool(dir)
+    }
+  });
+  player.look(arena.playerStart, [0, 1.5, arena.wallZ]);
+  let counter = 0;
+  let slot = 0;
+  const maxCarry = options.maxCarryKg ?? 60;
+  const massOfObject = (id) => {
+    const st = world.state(id);
+    let m = 0;
+    for (const p of st?.parts ?? []) if (p.status !== "broken" && p.status !== "melted" && p.status !== "ashes") m += p.mass;
+    return m;
+  };
+  const registerEntry = (objectId, itemId, root, spec, name, parts, item, arenaObject, movable) => {
+    specs.set(objectId, spec);
+    renderer.bind(objectId, root, parts ? { parts } : void 0);
+    const so = { objectId, itemId, root, movable };
+    const e = { so, item, name, arena: arenaObject, fluidOffset: [0, 0, 0], uses: [], piece: null, last: [root.position.x, root.position.y, root.position.z], velocity: [0, 0, 0] };
+    entries.set(objectId, e);
+    if (movable) {
+      e.piece = renderer.makePiece(objectId, { mass: Math.max(0.2, massOfObject(objectId)) });
+      rendererPieces.set(objectId, e.piece);
+    }
+    const f = item?.fluid;
+    if (f) {
+      e.fluidPart = f.part;
+      e.fluidOffset = f.offset ?? [0, 0, 0];
+      e.uses = f.uses ?? ["drink", "sip", "pour"];
+      root.updateMatrixWorld(true);
+      const q = root.getWorldQuaternion(tmpQ);
+      const p = tmpV.set(e.fluidOffset[0], e.fluidOffset[1], e.fluidOffset[2]).applyMatrix4(root.matrixWorld);
+      e.containerId = fluids.addContainer(f.container, { id: `${objectId}_fluid`, position: [p.x, p.y, p.z], rotation: [q.x, q.y, q.z, q.w] });
+      fluidView.bindContainer(e.containerId, root, { innerOffset: e.fluidOffset });
+    }
+    return e;
+  };
+  const resolveSpec = (item, root) => {
+    if (typeof item.spec === "function") return { spec: structuredCloneSpec(item.spec(root)) };
+    if (item.spec) return { spec: structuredCloneSpec(item.spec) };
+    const r = specFromObject3D(THREE, root, { name: item.id, ...item.specOptions });
+    return { spec: r.spec, parts: r.parts };
+  };
+  const addArena = () => {
+    for (const o of arena.objects) {
+      const root = buildFromSpec(THREE, o.spec, { colors: o.colors });
+      root.position.set(o.position[0], o.position[1], o.position[2]);
+      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);
+    }
+  };
+  addArena();
+  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);
+    let pos;
+    if (position) pos = [position[0], position[1], position[2]];
+    else {
+      const fx = -Math.sin(player.yaw);
+      const fz = -Math.cos(player.yaw);
+      const rx = Math.cos(player.yaw);
+      const rz = -Math.sin(player.yaw);
+      const side = (slot++ % 5 - 2) * 0.55;
+      const x = camera.position.x + fx * 2.4 + rx * side;
+      const z = camera.position.z + fz * 2.4 + rz * side;
+      const lim = arenaSize - 1;
+      pos = [Math.max(-lim, Math.min(lim, x)), groundAt(x, z), Math.max(-lim, Math.min(lim, z))];
+    }
+    root.position.set(pos[0], pos[1], pos[2]);
+    root.rotation.y = rotationY ?? player.yaw;
+    root.name = item.id;
+    scene.add(root);
+    root.updateMatrixWorld(true);
+    const objectId = `${item.id}_${++counter}`;
+    let own;
+    let resolved;
+    if (item.impl) {
+      own = item.impl(root, objectId);
+      if (own.id !== objectId) throw new Error(`game-test-room: item "${item.id}": DestructibleImpl.id is "${own.id}", the room gave it "${objectId}" (use the id passed to impl)`);
+      resolved = { spec: structuredCloneSpec(own.describe()) };
+    } else resolved = resolveSpec(item, root);
+    const { spec, parts } = resolved;
+    root.updateMatrixWorld(true);
+    const mass = spec.parts.reduce((m, p) => m + (p.mass ?? 0), 0);
+    const heavy = (mass || massGuess(spec)) > maxCarry;
+    const movable = own ? false : item.movable ?? !heavy;
+    if (movable) {
+      const box2 = new THREE.Box3().setFromObject(root);
+      const base = Math.max(pos[1], groundAt(pos[0], pos[2]));
+      pos = [pos[0], pos[1] + (base - box2.min.y), pos[2]];
+      root.position.set(pos[0], pos[1], pos[2]);
+      root.updateMatrixWorld(true);
+    }
+    const q = root.getWorldQuaternion(tmpQ);
+    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);
+    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;
+  };
+  const massGuess = (spec) => {
+    let m = 0;
+    for (const p of spec.parts) {
+      const s = p.shape;
+      const vol = s.kind === "box" ? s.size[0] * s.size[1] * s.size[2] : s.kind === "cylinder" ? Math.PI * s.radius * s.radius * s.height : 4 / 3 * Math.PI * s.radius ** 3;
+      m += p.mass ?? vol * (world.materials.get(p.material)?.density ?? 500) * (p.fill ?? 1);
+    }
+    return m;
+  };
+  const removeEntry = (id) => {
+    const e = entries.get(id);
+    if (!e) return;
+    if (heldEntry === e) releaseHeld();
+    for (let i = playing.length - 1; i >= 0; i--) if (playing[i].entry === e) playing.splice(i, 1);
+    if (e.containerId) {
+      fluidView.unbindContainer(e.containerId);
+      fluids.removeContainer(e.containerId);
+    }
+    try {
+      renderer.unbind(id);
+    } catch {
+    }
+    if (world.has(id)) world.remove(id);
+    e.so.root.removeFromParent();
+    entries.delete(id);
+    rendererPieces.delete(id);
+    specs.delete(id);
+  };
+  const clearLoose = () => {
+    for (const [id, owner] of [...splitOf]) {
+      void owner;
+      const p = rendererPieces.get(id);
+      try {
+        renderer.unbind(id);
+      } catch {
+      }
+      if (world.has(id)) world.remove(id);
+      p?.root.removeFromParent();
+      rendererPieces.delete(id);
+      splitOf.delete(id);
+    }
+    loose.length = 0;
+  };
+  const clearEverything = () => {
+    if (heldEntry || heldPiece) releaseHeld();
+    useItemPlayer = null;
+    playing.length = 0;
+    projectiles.length = 0;
+    clearProjectileMeshes();
+    fireZones.length = 0;
+    burningStains.length = 0;
+    for (const id of [...entries.keys()]) if (!entries.get(id)?.arena) removeEntry(id);
+    clearLoose();
+    for (const e of entries.values()) {
+      world.reset(e.so.objectId);
+      renderer.restore(e.so.objectId);
+    }
+    renderer.clear();
+    fluids.clearStains([0, 0, 0], 1e4);
+    fluidView.clear();
+    fluids.setTap(TAP_ID, false);
+  };
+  const clear = () => {
+    clearEverything();
+    pending = [];
+    action("clear", t("act.clear"));
+  };
+  const resetAll = () => {
+    for (const e of entries.values()) {
+      if (heldEntry === e) continue;
+      world.reset(e.so.objectId);
+      renderer.restore(e.so.objectId);
+      if (e.containerId) {
+        const c = fluids.container(e.containerId);
+        const f = e.item?.fluid?.container;
+        if (c && f && f.liquid) fluids.fill(e.containerId, f.liquid, Math.max(0, (f.liters ?? 0) - c.liters), f.temperature);
+      }
+    }
+    action("reset", t("act.reset"));
+  };
+  const hardReset = () => {
+    clearEverything();
+    for (const id of [...entries.keys()]) removeEntry(id);
+    tools.clear();
+    tool = toolState(toolId);
+    if (pristineWorld) {
+      for (const id of world.ids()) world.remove(id);
+      world.load(pristineWorld);
+    }
+    if (pristineFluids) {
+      fluids.load(pristineFluids);
+      for (const s of [...arena.surfaces, ...options.surfaces ?? []]) fluids.addSurface(s);
+    }
+    pending = [];
+    rng = 12345;
+    counter = 0;
+    slot = 0;
+    prevVy.clear();
+    lastImpact.clear();
+    addArena();
+    timeScale = 1;
+    fastForward = false;
+  };
+  const aimO = [0, 0, 0];
+  const aimD = [0, 0, -1];
+  const aim = () => {
+    camera.updateMatrixWorld(true);
+    camera.getWorldPosition(tmpV);
+    camera.getWorldDirection(tmpV2);
+    aimO[0] = tmpV.x;
+    aimO[1] = tmpV.y;
+    aimO[2] = tmpV.z;
+    aimD[0] = tmpV2.x;
+    aimD[1] = tmpV2.y;
+    aimD[2] = tmpV2.z;
+  };
+  const FAR = [0, 0, 0, 1];
+  const withoutHeld = (fn) => {
+    const e = heldEntry;
+    if (!e || !world.has(e.so.objectId)) return fn();
+    const p = e.so.root.position;
+    const q = e.so.root.quaternion;
+    world.setTransform(e.so.objectId, [0, -5e3, 0], FAR);
+    try {
+      return fn();
+    } finally {
+      world.setTransform(e.so.objectId, [p.x, p.y, p.z], [q.x, q.y, q.z, q.w]);
+    }
+  };
+  const rayWorld = (o, d, max) => withoutHeld(() => world.raycast(o, d, max));
+  let rng = 12345;
+  const rnd = () => {
+    rng = rng * 1664525 + 1013904223 >>> 0;
+    return rng / 4294967296;
+  };
+  const muzzle = () => {
+    aim();
+    const e = camera.matrixWorld.elements;
+    return [
+      aimO[0] + aimD[0] * 0.45 + e[0] * 0.16 - e[4] * 0.1,
+      aimO[1] + aimD[1] * 0.45 + e[1] * 0.16 - e[5] * 0.1,
+      aimO[2] + aimD[2] * 0.45 + e[2] * 0.16 - e[6] * 0.1
+    ];
+  };
+  const tracers = [];
+  const tracerMat = new THREE.LineBasicMaterial({ color: 16771496, transparent: true, opacity: 0.9 });
+  const tracer = (a, b) => {
+    let tr = tracers.find((x) => x.life <= 0);
+    if (!tr) {
+      if (tracers.length >= 12) return;
+      const g = new THREE.BufferGeometry();
+      g.setAttribute("position", new THREE.Float32BufferAttribute(6, 3));
+      const line = new THREE.Line(g, tracerMat);
+      line.frustumCulled = false;
+      scene.add(line);
+      tr = { line, life: 0 };
+      tracers.push(tr);
+    }
+    const attr = tr.line.geometry.getAttribute("position");
+    attr.setXYZ(0, a[0], a[1], a[2]);
+    attr.setXYZ(1, b[0], b[1], b[2]);
+    attr.needsUpdate = true;
+    tr.line.visible = true;
+    tr.life = 0.07;
+  };
+  const fireZones = [];
+  const burningStains = [];
+  const stainRadius = (s) => {
+    let sum = 0;
+    for (const r of s.front) sum += r;
+    return s.front.length ? sum / s.front.length : 0.1;
+  };
+  const stainBurning = (s) => burningStains.some((b) => dist3(b.center, s.center) < 0.05);
+  function igniteNear(point, reach) {
+    let lit = false;
+    let water = false;
+    for (const s of fluids.stains()) {
+      if (s.wetness < 0.05) continue;
+      if (Math.hypot(s.center[0] - point[0], s.center[2] - point[2]) > reach + stainRadius(s) || Math.abs(s.center[1] - point[1]) > 1.5) continue;
+      if (fluids.liquids.get(s.liquid)?.flammable) {
+        if (stainBurning(s)) continue;
+        const seconds = Math.max(3, Math.min(20, 4 + s.liters * 30 + stainRadius(s) * 6));
+        burningStains.push({ center: [s.center[0], s.center[1], s.center[2]], remaining: seconds, acc: 0 });
+        lit = true;
+        log.add({
+          channel: "event",
+          type: "stain_ignite",
+          text: t("ev.stain_ignite", { liquid: fStrings.liquids[s.liquid] ?? s.liquid, x: num(s.center[0], 1), z: num(s.center[2], 1), seconds: num(seconds, 0) }),
+          data: { stain: s.id, liquid: s.liquid, seconds }
+        });
+      } else water = true;
+    }
+    if (water && !lit) {
+      fluids.clearStains(point, Math.max(0.5, reach));
+      log.coalesce("dry", { channel: "event", type: "stain_dried_by_fire", text: t("ev.fire_dries"), data: { point } }, 2);
+    }
+  }
+  const hitFireAround = (point, radius, temperature, duration) => {
+    for (const id of world.ids()) world.hit(id, { type: "fire", point, temperature, radius, duration, source: "fire" });
+  };
+  const updateFires = (dt) => {
+    for (let i = fireZones.length - 1; i >= 0; i--) {
+      const z = fireZones[i];
+      z.remaining -= dt;
+      z.acc += dt;
+      if (z.acc >= 0.1) {
+        hitFireAround(z.point, z.radius, z.temperature, z.acc);
+        igniteNear(z.point, z.radius);
+        z.acc = 0;
+      }
+      const a = rnd() * Math.PI * 2;
+      const r = Math.sqrt(rnd()) * z.radius;
+      renderer.emit("fire", [z.point[0] + Math.cos(a) * r, z.point[1] + 0.05, z.point[2] + Math.sin(a) * r], [0, 1, 0], 2, 1.5);
+      if (z.remaining <= 0) fireZones.splice(i, 1);
+    }
+    if (burningStains.length) {
+      const stains = fluids.stains();
+      for (let i = burningStains.length - 1; i >= 0; i--) {
+        const b = burningStains[i];
+        b.remaining -= dt;
+        b.acc += dt;
+        const st = stains.find((s) => dist3(s.center, b.center) < 0.05);
+        const r = st ? stainRadius(st) : 0.3;
+        if (b.acc >= 0.1) {
+          hitFireAround([b.center[0], b.center[1] + 0.1, b.center[2]], r + 0.2, 800, b.acc);
+          b.acc = 0;
+        }
+        const a = rnd() * Math.PI * 2;
+        const rr = Math.sqrt(rnd()) * r;
+        renderer.emit("fire", [b.center[0] + Math.cos(a) * rr, b.center[1] + 0.05, b.center[2] + Math.sin(a) * rr], [0, 1, 0], 3, 1.8);
+        if (rnd() < 0.2) renderer.emit("smoke", [b.center[0], b.center[1] + 0.3, b.center[2]], [0, 1, 0], 1, 1);
+        if (b.remaining <= 0 || !st) {
+          fluids.clearStains(b.center, r + 0.1);
+          log.add({ channel: "event", type: "stain_burned", text: t("ev.stain_burned"), data: { point: b.center } });
+          burningStains.splice(i, 1);
+        }
+      }
+    }
+  };
+  let progress = null;
+  let statusLine = "";
+  let statusAt = 0;
+  const say = (msg) => {
+    statusLine = msg;
+    statusAt = simTime;
+    ui?.toast(msg);
+  };
+  const toolName = (id = toolId) => arsenal.name(id);
+  const hitWhere = (r) => {
+    const p = world.part(r.object, r.part);
+    return `${nameOf(r.object)} \u203A ${r.part}${p ? ` (${dStrings.materialNames[p.material] ?? p.material})` : ""}`;
+  };
+  const pushPiece = (objectId, dir, momentum, point) => {
+    if (!rendererPieces.has(objectId)) return;
+    renderer.impulse(objectId, [dir[0] * momentum, dir[1] * momentum, dir[2] * momentum], point);
+  };
+  const fireShots = (shots, recoil) => {
+    if (shots.length === 0) return;
+    const w = toolName();
+    const m = muzzle();
+    renderer.emit("flash", m, [aimD[0], aimD[1], aimD[2]], 1, 0);
+    renderer.emit("sparks", m, [aimD[0], aimD[1], aimD[2]], 4, 6);
+    let hits = 0;
+    let first = null;
+    let energy = 0;
+    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 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) {
+          hits++;
+          end = r0.point;
+          if (!first) first = { object: r0.object, part: r0.part, point: r0.point, normal: [0, 1, 0], distance: dist3(s.origin, r0.point) };
+          const speed = Math.max(80, s.speed);
+          pushPiece(r0.object, s.direction, 2 * s.energy / speed, r0.point);
+        }
+        if (shots.length <= 3 || rnd() < 0.34) tracer(m, end);
+      }
+    });
+    player.kick(recoil[0], recoil[1]);
+    const f = first;
+    const d = f ? num(f.distance, 1) : "";
+    let text;
+    if (shots.length === 1) text = t(f ? "act.shoot.hit" : "act.shoot.miss", { weapon: w, energy: num(energy, 0), where: f ? hitWhere(f) : "", dist: d });
+    else text = t("act.shoot.pellets", { weapon: w, n: shots.length, energy: num(energy, 0), hits, where: f ? hitWhere(f) : "", dist: d });
+    action("shoot", text, {
+      objectId: f?.object,
+      itemId: f ? entryOf(f.object)?.so.itemId : void 0,
+      part: f?.part,
+      data: { weapon: toolId, shots: shots.length, hits, energyJ: Math.round(energy), caliberMm: shots[0].caliber, distanceM: f ? Math.round(f.distance * 100) / 100 : null }
+    });
+  };
+  const fireRays = (u) => {
+    const d = new THREE.Vector3(u.direction[0], u.direction[1], u.direction[2]).normalize();
+    const out = [[d.x, d.y, d.z]];
+    if (u.cone) {
+      const a = Math.min(0.2, Math.atan2(u.radius, Math.max(0.1, u.range)));
+      const right = new THREE.Vector3().crossVectors(d, new THREE.Vector3(0, 1, 0));
+      if (right.lengthSq() < 1e-6) right.set(1, 0, 0);
+      right.normalize();
+      const up = new THREE.Vector3().crossVectors(right, d).normalize();
+      for (const [x, y] of [
+        [1, 0],
+        [-1, 0],
+        [0, 1],
+        [0, -1]
+      ]) {
+        const r = d.clone().addScaledVector(right, x * a).addScaledVector(up, y * a).normalize();
+        out.push([r.x, r.y, r.z]);
+      }
+    }
+    return out;
+  };
+  const heatRays = (u, type) => {
+    const w = toolName();
+    const cone = u.kind === "flame" ? u.cone : false;
+    const rays = fireRays({ origin: u.origin, direction: u.direction, range: u.range, cone, radius: u.radius });
+    let target = null;
+    const m = muzzle();
+    withoutHeld(() => {
+      for (const d of rays) {
+        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" });
+        if (type === "fire") igniteNear(r.point, 0.25);
+        else renderer.emit("sparks", r.point, r.normal, 2, 4);
+      }
+    });
+    if (type === "fire") {
+      renderer.emit("fire", m, [u.direction[0], u.direction[1], u.direction[2]], cone ? 5 : 1, Math.max(0.6, u.range * 1.1));
+      if (cone) renderer.emit("smoke", m, [u.direction[0], u.direction[1] + 0.3, u.direction[2]], 1, u.range * 0.5);
+      if (!target && u.direction[1] < -0.2) {
+        const t0 = (0.05 - u.origin[1]) / u.direction[1];
+        if (t0 > 0 && t0 < u.range) igniteNear([u.origin[0] + u.direction[0] * t0, 0.05, u.origin[2] + u.direction[2] * t0], 0.3);
+      }
+    }
+    const tg = target;
+    log.coalesce(
+      `use:${toolId}`,
+      {
+        channel: "action",
+        type,
+        text: tg ? t(type === "fire" ? "act.flame.hit" : "act.heat.hit", { weapon: w, where: hitWhere(tg), temp: num(u.temperature, 0) }) : t(type === "fire" ? "act.flame.air" : "act.heat.air", { weapon: w }),
+        objectId: tg?.object,
+        part: tg?.part,
+        data: { weapon: toolId, temperatureC: u.temperature }
+      },
+      1
+    );
+  };
+  const meleeUse = (u) => {
+    const w = toolName();
+    const r = rayWorld(u.origin, u.direction, u.reach);
+    if (!r) {
+      action("melee", t("act.melee.miss", { weapon: w }), { data: { weapon: toolId } });
+      return;
+    }
+    world.hitPart(r.object, r.part, { type: u.damage, point: r.point, direction: u.direction, energy: u.energy, radius: u.radius, 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,
+      itemId: entryOf(r.object)?.so.itemId,
+      part: r.part,
+      data: { weapon: toolId, damage: u.damage, energyJ: u.energy, distanceM: Math.round(r.distance * 100) / 100 }
+    });
+  };
+  const toolWork = (u, dt) => {
+    const w = toolName();
+    const r = rayWorld(u.origin, u.direction, u.reach);
+    if (!r) {
+      progress = null;
+      log.coalesce(`use:${toolId}`, { channel: "action", type: "tool", text: t("act.tool.none", { weapon: w }), data: { weapon: toolId } }, 1);
+      return;
+    }
+    const j = world.nearestJoint(r.object, r.point, 0.45);
+    if (!j) {
+      progress = null;
+      log.coalesce(`use:${toolId}`, { channel: "action", type: "tool", text: t("act.tool.nojoint", { weapon: w, where: hitWhere(r) }), objectId: r.object, part: r.part }, 1);
+      return;
+    }
+    const tool_ = u.tool;
+    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");
+      progress = { label: t("hud.refused", { kind }), value: 0, at: simTime };
+      log.coalesce(
+        `refuse:${r.object}:${j.id}:${toolId}`,
+        {
+          channel: "action",
+          type: "tool_refused",
+          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 }
+        },
+        2
+      );
+      return;
+    }
+    progress = { label: `${kind} (${j.id})`, value: p, at: simTime };
+    renderer.emit("sparks", r.point, r.normal, 1, 2);
+  };
+  const extinguishUse = (u) => {
+    const w = toolName();
+    const rays = fireRays({ origin: u.origin, direction: u.direction, range: u.range, cone: true, radius: 0.6 });
+    const m = muzzle();
+    renderer.emit("foam", m, [u.direction[0], u.direction[1], u.direction[2]], 8, u.range * 1.2);
+    const hit = /* @__PURE__ */ new Set();
+    withoutHeld(() => {
+      for (const d of rays) {
+        const r = world.raycast(u.origin, d, u.range);
+        if (!r) continue;
+        hit.add(r.object);
+        world.extinguish(r.object, void 0, u.coolC * Math.max(u.duration, 0.05) * 6);
+        fluids.clearStains(r.point, 0.5);
+        for (let i = burningStains.length - 1; i >= 0; i--) if (Math.hypot(burningStains[i].center[0] - r.point[0], burningStains[i].center[2] - r.point[2]) < 1.2) burningStains.splice(i, 1);
+        for (let i = fireZones.length - 1; i >= 0; i--) if (Math.hypot(fireZones[i].point[0] - r.point[0], fireZones[i].point[2] - r.point[2]) < 1.5) fireZones.splice(i, 1);
+      }
+    });
+    log.coalesce(
+      `use:${toolId}`,
+      { channel: "action", type: "extinguish", text: hit.size ? t("act.extinguish.hit", { weapon: w, what: [...hit].map(nameOf).join(", ") }) : t("act.extinguish.air", { weapon: w }), data: { objects: [...hit] } },
+      1
+    );
+  };
+  const projectiles = [];
+  const projMeshes = [];
+  const clearProjectileMeshes = () => {
+    for (const m of projMeshes) m.removeFromParent();
+    projMeshes.length = 0;
+  };
+  const throwUse = (u) => {
+    const w = toolName();
+    const molotov = !!u.fire;
+    const mesh = new THREE.Mesh(
+      molotov ? new THREE.CylinderGeometry(0.035, 0.04, 0.2, 8) : new THREE.SphereGeometry(0.045, 8, 6),
+      new THREE.MeshStandardMaterial({ color: molotov ? 3897915 : 4936480, roughness: 0.6, metalness: molotov ? 0 : 0.4 })
+    );
+    mesh.castShadow = true;
+    mesh.position.set(u.origin[0], u.origin[1], u.origin[2]);
+    scene.add(mesh);
+    projMeshes.push(mesh);
+    projectiles.push({
+      mesh,
+      pos: new THREE.Vector3(u.origin[0], u.origin[1], u.origin[2]),
+      vel: new THREE.Vector3(u.velocity[0], u.velocity[1], u.velocity[2]),
+      weapon: toolId,
+      fuse: u.fuse,
+      burstOnImpact: molotov && u.fuse <= 0,
+      energy: u.energy,
+      radius: u.radius,
+      fire: u.fire,
+      age: 0
+    });
+    action("throw_projectile", t(molotov ? "act.throw.molotov" : "act.throw.grenade", { weapon: w, fuse: num(u.fuse, 1) }), { data: { weapon: toolId, fuse: u.fuse } });
+  };
+  const detonate = (p, at, impact) => {
+    const w = toolName(p.weapon);
+    const results = world.explode(at, p.energy, p.radius, "player");
+    action("explode", t("act.explode", { weapon: w, energy: num(p.energy, 0), radius: num(p.radius, 1), n: results.length }), { data: { weapon: p.weapon, energyJ: p.energy, radius: p.radius, point: at } });
+    if (p.fire) {
+      fluids.splash("fuel", [at[0], Math.max(at[1], groundAt(at[0], at[2])), at[2]], 0.5);
+      fireZones.push({ point: [at[0], Math.max(0.02, groundAt(at[0], at[2])), at[2]], radius: p.fire.radius, temperature: p.fire.temperature, remaining: p.fire.seconds, acc: 0 });
+      renderer.emit("fire", at, [0, 1, 0], 24, 3);
+      action("molotov_fire", t("act.molotov_fire", { weapon: w, seconds: num(p.fire.seconds, 0), radius: num(p.fire.radius, 1) }), { data: { weapon: p.weapon, impact } });
+    }
+  };
+  const updateProjectiles = (dt) => {
+    for (let i = projectiles.length - 1; i >= 0; i--) {
+      const p = projectiles[i];
+      p.age += dt;
+      p.vel.y -= 9.81 * dt;
+      const speed = p.vel.length();
+      const step2 = speed * dt;
+      let burst = false;
+      if (step2 > 1e-6) {
+        const d = [p.vel.x / speed, p.vel.y / speed, p.vel.z / speed];
+        const r = withoutHeld(() => world.raycast(v3(p.pos), d, step2 + 0.05));
+        if (r && r.distance <= step2 + 0.04) {
+          p.pos.set(r.point[0] - d[0] * 0.03, r.point[1] - d[1] * 0.03, r.point[2] - d[2] * 0.03);
+          if (p.burstOnImpact) burst = true;
+          else {
+            const n = r.normal;
+            const vn = p.vel.x * n[0] + p.vel.y * n[1] + p.vel.z * n[2];
+            p.vel.x = (p.vel.x - 2 * vn * n[0]) * 0.35;
+            p.vel.y = (p.vel.y - 2 * vn * n[1]) * 0.35;
+            p.vel.z = (p.vel.z - 2 * vn * n[2]) * 0.35;
+          }
+        } else p.pos.addScaledVector(p.vel, dt);
+      }
+      const g = groundAt(p.pos.x, p.pos.z) + 0.045;
+      if (p.pos.y < g) {
+        p.pos.y = g;
+        if (p.burstOnImpact) burst = true;
+        else {
+          p.vel.y = Math.abs(p.vel.y) * 0.35;
+          p.vel.x *= 0.7;
+          p.vel.z *= 0.7;
+        }
+      }
+      p.mesh.position.copy(p.pos);
+      p.mesh.rotation.x += dt * 8;
+      p.fuse -= dt;
+      if (burst || !p.burstOnImpact && p.fuse <= 0 || p.age > 30) {
+        detonate(p, v3(p.pos), burst);
+        p.mesh.removeFromParent();
+        projMeshes.splice(projMeshes.indexOf(p.mesh), 1);
+        projectiles.splice(i, 1);
+      }
+    }
+  };
+  const useTool = (dt, held) => {
+    aim();
+    const cat = tool.def.category;
+    if (cat === "hand") return;
+    const res = tool.trigger([aimO[0], aimO[1], aimO[2]], [aimD[0], aimD[1], aimD[2]], dt, held, "player");
+    if (res.status === "empty") {
+      if (!tool.reloading && tool.reserve > 0) tool.reload();
+      say(t(tool.reloading ? "hud.reloading" : "hud.empty"));
+      return;
+    }
+    if (res.status !== "ok") {
+      if (res.status === "reloading") say(t("hud.reloading"));
+      else if (res.status === "no_fuel") say(t("hud.no_fuel"));
+      return;
+    }
+    if (res.shots.length) fireShots(res.shots, res.recoil);
+    for (const u of res.uses) {
+      switch (u.kind) {
+        case "melee":
+          meleeUse(u);
+          break;
+        case "flame":
+          heatRays(u, "fire");
+          break;
+        case "heat":
+          heatRays(u, "heat");
+          break;
+        case "throw":
+          throwUse(u);
+          break;
+        case "tool":
+          toolWork(u, dt);
+          break;
+        case "extinguish":
+          extinguishUse(u);
+          break;
+        default:
+          break;
+      }
+    }
+  };
+  const setTool = (id) => {
+    if (!arsenal.weapons.has(id)) throw new Error(`game-test-room: unknown weapon "${id}"`);
+    tool.release();
+    toolId = id;
+    const i = loadout.indexOf(id);
+    if (i >= 0) toolIndex = i;
+    tool = toolState(id);
+    progress = null;
+    action("tool", t("act.tool", { weapon: toolName(id) }), { data: { weapon: id } });
+    fire("tool", id);
+  };
+  const cycleTool = (dir) => {
+    if (!loadout.length) return;
+    toolIndex = (toolIndex + dir + loadout.length) % loadout.length;
+    setTool(loadout[toolIndex]);
+  };
+  let heldEntry = null;
+  let heldPiece = null;
+  let heldName = "";
+  let heldYaw = 0;
+  let heldTilt = 0;
+  let tiltKey = 0;
+  const heldLocal = new THREE.Vector3();
+  const heldVel = [0, 0, 0];
+  let useItemPlayer = null;
+  let useItemName = "";
+  const releaseHeld = () => {
+    if (heldPiece) {
+      heldPiece.held = false;
+      heldPiece.sleeping = false;
+      heldPiece.velocity = [heldVel[0], heldVel[1], heldVel[2]];
+    }
+    useItemPlayer?.cancel();
+    useItemPlayer = null;
+    heldEntry = null;
+    heldPiece = null;
+    heldTilt = 0;
+  };
+  const grab = () => {
+    if (heldPiece) {
+      const name = heldName;
+      releaseHeld();
+      action("drop", t("act.drop", { name }));
+      fire("grab", { held: false });
+      return true;
+    }
+    aim();
+    const r = rayWorld([aimO[0], aimO[1], aimO[2]], [aimD[0], aimD[1], aimD[2]], 3.2);
+    if (!r) {
+      say(t("hud.nothing_to_grab"));
+      return false;
+    }
+    const piece = rendererPieces.get(r.object);
+    if (!piece) {
+      say(t("hud.cannot_grab", { name: nameOf(r.object) }));
+      return false;
+    }
+    const kg = piece.mass;
+    if (kg > maxCarry) {
+      say(t("hud.too_heavy", { name: nameOf(r.object), kg: num(kg, 0) }));
+      return false;
+    }
+    heldPiece = piece;
+    heldEntry = entries.get(r.object) ?? null;
+    heldName = nameOf(r.object);
+    piece.held = true;
+    piece.sleeping = false;
+    const box2 = new THREE.Box3().setFromObject(piece.root);
+    const c = box2.getCenter(new THREE.Vector3());
+    piece.root.updateMatrixWorld(true);
+    heldLocal.copy(c).sub(piece.root.position);
+    heldLocal.applyQuaternion(piece.root.quaternion.clone().invert());
+    heldYaw = 0;
+    heldTilt = 0;
+    heldVel[0] = heldVel[1] = heldVel[2] = 0;
+    action("grab", t("act.grab", { name: heldName, kg: num(kg, 1) }), { objectId: r.object, itemId: entryOf(r.object)?.so.itemId, data: { massKg: Math.round(kg * 10) / 10 } });
+    fire("grab", { held: true, objectId: r.object });
+    return true;
+  };
+  const throwHeld = (speed = 9) => {
+    if (!heldPiece) return false;
+    const piece = heldPiece;
+    const name = heldName;
+    const id = piece.objectId;
+    aim();
+    releaseHeld();
+    piece.velocity = [0, 0, 0];
+    renderer.impulse(id, [aimD[0] * speed * piece.mass, (aimD[1] * speed + 1.2) * piece.mass, aimD[2] * speed * piece.mass]);
+    action("throw", t("act.throw", { name, speed: num(speed, 1) }), { objectId: id, itemId: entryOf(id)?.so.itemId, data: { speedMs: speed, massKg: piece.mass } });
+    fire("throw", { objectId: id, speed });
+    return true;
+  };
+  const followHeld = (dt) => {
+    const piece = heldPiece;
+    if (!piece) return;
+    camera.updateMatrixWorld(true);
+    const root = piece.root;
+    let pos;
+    const targetQ = tmpQ;
+    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);
+      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);
+      targetQ.setFromAxisAngle(new THREE.Vector3(0, 1, 0), player.yaw + heldYaw);
+      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;
+    const py = root.position.y;
+    const pz = root.position.z;
+    root.quaternion.slerp(targetQ, Math.min(1, k * 0.9));
+    const off2 = tmpV2.copy(heldLocal).applyQuaternion(root.quaternion);
+    root.position.set(root.position.x + (pos.x - off2.x - root.position.x) * k, root.position.y + (pos.y - off2.y - root.position.y) * k, root.position.z + (pos.z - off2.z - root.position.z) * k);
+    if (dt > 0) {
+      heldVel[0] = (root.position.x - px) / dt;
+      heldVel[1] = (root.position.y - py) / dt;
+      heldVel[2] = (root.position.z - pz) / dt;
+    }
+    root.updateMatrixWorld(true);
+  };
+  const useItem = (useId) => {
+    const e = heldEntry;
+    if (!e?.containerId) return false;
+    const def = itemUseDefs.find((u) => u.id === useId);
+    if (!def) return false;
+    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) {
+      say(t("hud.empty_container", { name: e.name }));
+      return false;
+    }
+    if (useItemPlayer && !useItemPlayer.done) return false;
+    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 } });
+    return true;
+  };
+  const updateItemUse = (dt) => {
+    if (!useItemPlayer) return;
+    useItemPlayer.update(dt);
+    if (useItemPlayer.done) {
+      useItemPlayer = null;
+      useItemName = "";
+    }
+  };
+  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 });
+  const isTapOn = () => fluids.taps().some((x) => x.id === TAP_ID && x.on);
+  const toggleTap = (on = !isTapOn()) => {
+    fluids.setTap(TAP_ID, on);
+    action("tap", t(on ? "act.tap.on" : "act.tap.off"));
+    return on;
+  };
+  const lastImpact = /* @__PURE__ */ new Map();
+  const MIN_LANDING_LOG = 3;
+  const updateImpacts = () => {
+    const check = (piece) => {
+      if (piece.held || piece.sleeping) return;
+      const v = piece.velocity;
+      const speed = Math.hypot(v[0], v[1], v[2]);
+      if (speed < 3.5) return;
+      if ((lastImpact.get(piece.objectId) ?? -9) > simTime - 0.25) return;
+      const dir = [v[0] / speed, v[1] / speed, v[2] / speed];
+      const c = tmpV.copy(new THREE.Vector3(0, 0, 0));
+      void c;
+      const box2 = tmpBox.setFromObject(piece.root);
+      const centre = box2.getCenter(tmpV);
+      const size = box2.getSize(tmpV2);
+      const reach = Math.max(size.x, size.y, size.z) * 0.5;
+      const origin = [centre.x + dir[0] * (reach + 0.02), centre.y + dir[1] * (reach + 0.02), centre.z + dir[2] * (reach + 0.02)];
+      const r = withoutHeld(() => world.raycast(origin, dir, speed * FIXED_DT * 2 + 0.06));
+      if (!r || r.object === piece.objectId) return;
+      const energy = 0.5 * piece.mass * speed * speed;
+      lastImpact.set(piece.objectId, simTime);
+      world.hitPart(r.object, r.part, { type: "blunt", point: r.point, direction: dir, energy, radius: 0.08, source: "thrown" });
+      if (world.has(piece.objectId)) world.hit(piece.objectId, { type: "blunt", point: r.point, direction: [-dir[0], -dir[1], -dir[2]], energy: energy * 0.4, radius: 0.08, source: "thrown" });
+      pushPiece(r.object, dir, piece.mass * speed * 0.5, r.point);
+      piece.velocity = [-v[0] * 0.25, Math.abs(v[1]) * 0.3 + 0.5, -v[2] * 0.25];
+      action("impact", t("act.impact", { name: nameOf(piece.objectId), where: hitWhere(r), energy: num(energy, 0), speed: num(speed, 1) }), {
+        objectId: piece.objectId,
+        itemId: entryOf(piece.objectId)?.so.itemId,
+        data: { energyJ: Math.round(energy), speedMs: Math.round(speed * 10) / 10, target: r.object, targetPart: r.part }
+      });
+    };
+    const land = (piece) => {
+      const vy = piece.velocity[1];
+      const prev = prevVy.get(piece.objectId) ?? 0;
+      prevVy.set(piece.objectId, vy);
+      if (piece.held || prev > -MIN_LANDING_LOG || vy < prev + 2 || !world.has(piece.objectId)) return;
+      const energy = 0.5 * piece.mass * prev * prev;
+      action("landing", t("act.landing", { name: nameOf(piece.objectId), speed: num(-prev, 1), energy: num(energy, energy < 100 ? 1 : 0) }), {
+        objectId: piece.objectId,
+        itemId: entryOf(piece.objectId)?.so.itemId,
+        data: { energyJ: Math.round(energy * 10) / 10, speedMs: Math.round(-prev * 10) / 10 }
+      });
+    };
+    for (const e of entries.values()) if (e.piece) {
+      check(e.piece);
+      land(e.piece);
+    }
+    for (const p of loose) {
+      check(p);
+      land(p);
+    }
+  };
+  const prevVy = /* @__PURE__ */ new Map();
+  const tmpBox = new THREE.Box3();
+  const onKey = (code, down, e) => {
+    if (!down) {
+      if (code === "KeyZ") tiltKey = 0;
+      return;
+    }
+    const digit = /^Digit(\d)$/.exec(code);
+    if (digit && !e.ctrlKey && !e.metaKey) {
+      const n = (Number(digit[1]) + 9) % 10;
+      const page = Math.floor(toolIndex / 10);
+      const idx = page * 10 + n;
+      if (idx < loadout.length) setTool(loadout[idx]);
+      return;
+    }
+    switch (code) {
+      case "KeyE":
+        grab();
+        break;
+      case "KeyG":
+        throwHeld();
+        break;
+      case "KeyR":
+        if (heldPiece) heldYaw += Math.PI / 8;
+        else {
+          tool.reload();
+          say(t("hud.reloading"));
+        }
+        break;
+      case "KeyQ":
+        tool.cycleMode();
+        break;
+      case "KeyZ":
+        tiltKey = 1;
+        break;
+      case "KeyF":
+        if (heldEntry?.uses[0]) useItem(heldEntry.uses[0]);
+        break;
+      case "KeyC":
+        if (heldEntry?.uses[1]) useItem(heldEntry.uses[1]);
+        break;
+      case "KeyV":
+        if (heldEntry?.uses[2]) useItem(heldEntry.uses[2]);
+        else toggleTap();
+        break;
+      case "KeyT":
+        toggleTap();
+        break;
+      case "KeyH": {
+        const w = (heldEntry ?? entryOf(inspectTarget()?.object ?? ""))?.item?.weapon;
+        if (w) equip(w);
+        break;
+      }
+      case "BracketRight":
+        toolIndex = Math.min(loadout.length - 1, (Math.floor(toolIndex / 10) + 1) * 10);
+        setTool(loadout[toolIndex]);
+        break;
+      case "BracketLeft":
+        toolIndex = Math.max(0, (Math.floor(toolIndex / 10) - 1) * 10);
+        setTool(loadout[toolIndex]);
+        break;
+      case "Tab":
+        ui?.togglePanels();
+        break;
+      default:
+        break;
+    }
+  };
+  const equip = (weaponId) => {
+    if (!arsenal.weapons.has(weaponId)) return;
+    if (!loadout.includes(weaponId)) loadout.push(weaponId);
+    setTool(weaponId);
+  };
+  const inspectTarget = () => {
+    aim();
+    return rayWorld(aimO, aimD, 14);
+  };
+  const inspectInfo = () => {
+    const r = inspectTarget();
+    if (!r) return null;
+    const st = world.state(r.object);
+    const p = world.part(r.object, r.part);
+    if (!st || !p) return null;
+    const e = entryOf(r.object);
+    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),
+      open: j.open,
+      progress: j.progress
+    }));
+    const ext = p;
+    return {
+      object: nameOf(r.object),
+      objectId: r.object,
+      part: r.part,
+      material: S.text[`material.${p.material}`] ?? dStrings.materialNames[p.material] ?? p.material,
+      status: dStrings.partStatus[p.status] ?? p.status,
+      hp: p.hp,
+      maxHp: p.maxHp,
+      temperature: p.temperature,
+      burning: p.burning,
+      char: p.char,
+      melt: p.melt,
+      liters: p.liters,
+      dents: p.dents.length,
+      holes: p.holes.length,
+      cracks: p.cracks.length,
+      mass: p.mass,
+      load: ext.load,
+      stress: ext.stress,
+      joints,
+      note: e?.item?.note,
+      distance: r.distance
+    };
+  };
+  let timeScale = 1;
+  let fastForward = false;
+  let hudAcc = 1;
+  let qualityName = quality;
+  const syncContainers = (sdt) => {
+    for (const e of entries.values()) {
+      if (!e.containerId) continue;
+      const host = hostOf(e);
+      host.root.updateMatrixWorld(true);
+      const q = host.root.getWorldQuaternion(tmpQ);
+      const p = tmpV.set(e.fluidOffset[0], e.fluidOffset[1], e.fluidOffset[2]).applyMatrix4(host.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 syncLiters = () => {
+    for (const e of entries.values()) {
+      if (!e.containerId || !e.fluidPart) continue;
+      const c = fluids.container(e.containerId);
+      if (!c) continue;
+      const host = hostOf(e);
+      const part = world.part(host.objectId, e.fluidPart);
+      if (part && part.liters !== void 0 && Math.abs(part.liters - c.liters) > 1e-4) world.setLiters(host.objectId, e.fluidPart, c.liters);
+    }
+  };
+  const stepSim = (dt) => {
+    simTime += dt;
+    const reps = fastForward ? 10 : 1;
+    updateAnimations(dt);
+    updateItemUse(dt);
+    updateProjectiles(dt);
+    syncContainers(dt);
+    for (let i = 0; i < reps; i++) {
+      world.update(dt);
+      if (i === 0) updateFires(dt);
+      fluids.update(dt);
+    }
+    syncLiters();
+    renderer.update(dt);
+    updateImpacts();
+    fluidView.update(dt);
+    for (const s of tools.values()) s.update(dt);
+    for (const tr of tracers) {
+      if (tr.life > 0) {
+        tr.life -= dt;
+        if (tr.life <= 0) tr.line.visible = false;
+      }
+    }
+    flush();
+  };
+  const update = (dt) => {
+    player.update(dt);
+    if (tiltKey || heldTilt > 0) {
+      heldTilt = Math.max(0, Math.min(2.4, heldTilt + (tiltKey ? 2.2 : -3) * dt));
+    }
+    if (useHeld) {
+      if (tool.def.category === "hand") {
+        if (useFirst) grab();
+      } else useTool(dt, !useFirst);
+      useFirst = false;
+    }
+    followHeld(dt);
+    stepSim(dt * timeScale);
+    if (progress && simTime - progress.at > 0.25) progress = null;
+    hudAcc += dt;
+    if (hudAcc >= 0.1 && ui) {
+      hudAcc = 0;
+      ui.hud(hudState());
+    }
+  };
+  const hudState = () => {
+    const page = Math.floor(toolIndex / 10);
+    const slots = loadout.slice(page * 10, page * 10 + 10).map((id) => arsenal.name(id));
+    const ammo = tool.def.action.kind === "firearm" ? `${tool.ammo}/${tool.capacity}${tool.reserve ? ` \xB7 ${tool.reserve}` : ""}` : tool.def.action.kind === "hand" ? "" : tool.def.action.kind === "melee" || tool.def.action.kind === "tool" ? "" : `${num(tool.ammo, 0)}`;
+    return {
+      toolName: toolName(),
+      toolId,
+      ammo,
+      slots,
+      slot: toolIndex - page * 10,
+      page: page + 1,
+      pages: Math.max(1, Math.ceil(loadout.length / 10)),
+      status: simTime - statusAt < 2 ? statusLine : "",
+      progress: progress ? { label: progress.label, value: progress.value } : null,
+      held: heldEntry || heldPiece ? { name: heldName, uses: (heldEntry?.uses ?? []).map((u, i) => ({ key: ["F", "C", "V"][i] ?? "", label: S.text[`use.${u}`] ?? u })), weapon: heldEntry?.item?.weapon ? arsenal.name(heldEntry.item.weapon) : void 0, using: useItemName } : null,
+      inspect: inspectInfo(),
+      animations: animationsOf(),
+      locked: player.locked,
+      timeScale,
+      fast: fastForward,
+      tap: isTapOn(),
+      quality: qualityName,
+      objects: [...entries.values()].filter((e) => !e.arena).length
+    };
+  };
+  const playing = [];
+  const restPose = /* @__PURE__ */ new WeakMap();
+  const ZERO = [0, 0, 0];
+  const animTarget = () => {
+    if (heldEntry) return heldEntry;
+    const r = inspectTarget();
+    return r ? entryOf(r.object) : void 0;
+  };
+  const poseAt = (clip, id, time) => {
+    const pick = (k) => id === null ? k : k.parts?.[id];
+    const pts = clip.keys.map((k) => ({ t: k.t, position: pick(k)?.position ?? ZERO, rotation: pick(k)?.rotation ?? ZERO }));
+    if (pts.length === 0 || pts[0].t > 0) pts.unshift({ t: 0, position: ZERO, rotation: ZERO });
+    let a = pts[0];
+    let b = pts[pts.length - 1];
+    if (time >= b.t) a = b;
+    else for (let i = 0; i < pts.length - 1; i++) if (time >= pts[i].t && time < pts[i + 1].t) [a, b] = [pts[i], pts[i + 1]];
+    const f = a === b || b.t <= a.t ? 0 : (time - a.t) / (b.t - a.t);
+    const mix = (x, y) => [x[0] + (y[0] - x[0]) * f, x[1] + (y[1] - x[1]) * f, x[2] + (y[2] - x[2]) * f];
+    return { position: mix(a.position, b.position), rotation: mix(a.rotation, b.rotation) };
+  };
+  const applyClip = (pl) => {
+    for (const [id, obj] of pl.targets) {
+      const rest = restPose.get(obj);
+      if (!rest) continue;
+      const pose = poseAt(pl.clip, id === "" ? null : id, pl.t);
+      obj.position.set(rest.p[0] + pose.position[0], rest.p[1] + pose.position[1], rest.p[2] + pose.position[2]);
+      obj.rotation.set(rest.r[0] + pose.rotation[0], rest.r[1] + pose.rotation[1], rest.r[2] + pose.rotation[2]);
+    }
+  };
+  const updateAnimations = (dt) => {
+    for (let i = playing.length - 1; i >= 0; i--) {
+      const pl = playing[i];
+      pl.t = Math.min(pl.clip.duration, pl.t + dt);
+      applyClip(pl);
+      const evs = pl.clip.events ?? [];
+      while (pl.fired < evs.length && evs[pl.fired].t <= pl.t) {
+        const ev = evs[pl.fired++];
+        action("animation_event", t("act.anim_event", { name: pl.entry.name, clip: pl.clip.id, type: ev.type }), { objectId: pl.entry.so.objectId, itemId: pl.entry.so.itemId, data: { clip: pl.clip.id, type: ev.type, at: ev.t, ...ev.data ?? {} } });
+        const key = ev.type === "sound" ? ev.data?.key : void 0;
+        if (typeof key === "string") options.onSound?.(key, v3(pl.entry.so.root.getWorldPosition(tmpV)), 1);
+      }
+      if (pl.t >= pl.clip.duration) {
+        playing.splice(i, 1);
+        action("animation_end", t("act.anim_end", { name: pl.entry.name, clip: pl.clip.id }), { objectId: pl.entry.so.objectId, itemId: pl.entry.so.itemId, data: { clip: pl.clip.id } });
+      }
+    }
+  };
+  const animationsOf = () => {
+    const e = animTarget();
+    if (!e || e.arena) return null;
+    const clips = (e.item?.animations ?? []).map((c) => ({ id: c.id, duration: c.duration }));
+    return { objectId: e.so.objectId, itemId: e.so.itemId, name: e.name, clips, playing: playing.find((p) => p.entry === e)?.clip.id ?? null };
+  };
+  const playAnimation = (clipId, objectId) => {
+    const e = objectId ? entries.get(objectId) : animTarget();
+    const clip = e?.item?.animations?.find((c) => c.id === clipId);
+    if (!e || !clip) return false;
+    for (let i = playing.length - 1; i >= 0; i--) if (playing[i].entry === e && playing[i].clip.id === clipId) playing.splice(i, 1);
+    const targets = /* @__PURE__ */ new Map();
+    const ids = /* @__PURE__ */ new Set();
+    for (const k of clip.keys) for (const id of Object.keys(k.parts ?? {})) ids.add(id);
+    const grab2 = (key, obj) => {
+      if (!obj) return;
+      if (!restPose.has(obj)) restPose.set(obj, { p: [obj.position.x, obj.position.y, obj.position.z], r: [obj.rotation.x, obj.rotation.y, obj.rotation.z] });
+      targets.set(key, obj);
+    };
+    if (clip.keys.some((k) => k.position || k.rotation)) grab2("", e.so.root);
+    for (const id of ids) grab2(id, e.so.root.getObjectByName(id) ?? void 0);
+    const pl = { entry: e, clip, t: 0, fired: 0, targets };
+    playing.push(pl);
+    applyClip(pl);
+    action("animation", t("act.anim_start", { name: e.name, clip: clip.id, seconds: num(clip.duration, 1) }), { objectId: e.so.objectId, itemId: e.so.itemId, data: { clip: clip.id, duration: clip.duration } });
+    return true;
+  };
+  const extraScenarios = [...options.scenarios ?? []];
+  const moduleCheck = (ok, text, data, itemId) => {
+    log.add({ channel: "check", type: ok ? "pass" : "fail", text: `${ok ? "\u2713" : "\u2717"} ${text}`, itemId, data: { ok, ...data } });
+  };
+  const loadModule = (mod) => {
+    const report = { module: mod.id, items: [], scenarios: [], ok: true, problems: [] };
+    const fail = (problem) => {
+      report.ok = false;
+      report.problems.push(problem);
+    };
+    const added = mod.items(locale);
+    for (const ti of added) {
+      const item = {
+        id: ti.id,
+        name: ti.name,
+        group: mod.group,
+        build: (T) => ti.build(T),
+        spec: ti.spec,
+        movable: ti.movable,
+        fluid: ti.fluid,
+        weapon: ti.weapon,
+        impl: ti.impl,
+        animations: ti.animations
+      };
+      catalogMap.set(item.id, item);
+      const at = catalog.findIndex((c) => c.id === item.id);
+      if (at >= 0) catalog[at] = item;
+      else catalog.push(item);
+      report.items.push(item.id);
+      let partIds = [];
+      const base = { module: mod.id, item: item.id };
+      try {
+        const root = item.build(THREE);
+        root.updateMatrixWorld(true);
+        if (item.impl) {
+          const probe = item.impl(root, `${item.id}_check`);
+          const r = checkDestructible(probe, { materials: world.materials.keys() });
+          partIds = probe.describe().parts.map((p) => p.id);
+          moduleCheck(r.ok, r.ok ? t("mod.destructible_ok", { name: item.name, parts: partIds.length }) : t("mod.destructible_fail", { name: item.name, problems: r.problems.join("; ") }), { ...base, check: "destructible", problems: r.problems }, item.id);
+          for (const p of r.problems) fail(`${item.id}: ${p}`);
+        } else {
+          partIds = resolveSpec(item, root).spec.parts.map((p) => p.id);
+        }
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        moduleCheck(false, t("mod.destructible_fail", { name: item.name, problems: msg }), { ...base, check: "destructible", problems: [msg] }, item.id);
+        fail(`${item.id}: ${msg}`);
+      }
+      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);
+        for (const p of r.problems) fail(`${item.id}: ${p}`);
+      }
+    }
+    for (const ms of mod.scenarios?.(locale) ?? []) {
+      const sc = { id: ms.id, name: ms.name, run: ms.run };
+      const at = extraScenarios.findIndex((x) => x.id === sc.id);
+      if (at >= 0) extraScenarios[at] = sc;
+      else extraScenarios.push(sc);
+      report.scenarios.push(sc.id);
+    }
+    action("module", t("act.module_loaded", { name: mod.name, items: report.items.length, scenarios: report.scenarios.length, result: t(report.ok ? "mod.all_ok" : "mod.some_failed") }), { data: { module: mod.id, items: report.items, scenarios: report.scenarios, ok: report.ok } });
+    ui?.refresh();
+    return report;
+  };
+  const allScenarios = () => [...makeScenarios(t, num, locale), ...extraScenarios];
+  let scenarioRunning = false;
+  const step = (seconds) => {
+    const dt = seconds > 6 ? 1 / 30 : FIXED_DT;
+    const n = Math.max(1, Math.round(seconds / dt));
+    for (let i = 0; i < n; i++) {
+      player.update(0);
+      followHeld(dt);
+      stepSim(dt);
+    }
+  };
+  const runScenarios = async (list) => {
+    const all = list ?? allScenarios();
+    const report = { passed: 0, failed: 0, results: [] };
+    scenarioRunning = true;
+    try {
+      for (const sc of all) {
+        hardReset();
+        player.look(arena.playerStart, [0, 1.5, arena.wallZ]);
+        useHeld = false;
+        const checks = [];
+        log.add({ channel: "check", type: "scenario", text: t("sc.start", { name: sc.name }), data: { id: sc.id } });
+        const ctx = {
+          room,
+          step,
+          expect(condition, label, data) {
+            checks.push({ label, ok: !!condition });
+            log.add({ channel: "check", type: condition ? "pass" : "fail", text: `${condition ? "\u2713" : "\u2717"} ${label}`, data: { scenario: sc.id, ok: !!condition, ...data ?? {} } });
+          }
+        };
+        try {
+          await sc.run(ctx);
+        } catch (err) {
+          const msg = err instanceof Error ? err.message : String(err);
+          ctx.expect(false, t("sc.error", { msg }));
+        }
+        flush();
+        const ok = checks.length > 0 && checks.every((c) => c.ok);
+        report.results.push({ id: sc.id, name: sc.name, ok, checks });
+        if (ok) report.passed++;
+        else report.failed++;
+        log.add({ channel: "check", type: ok ? "scenario_pass" : "scenario_fail", text: t(ok ? "sc.pass" : "sc.fail", { name: sc.name }), data: { id: sc.id, ok } });
+        await new Promise((res) => setTimeout(res, 0));
+      }
+    } finally {
+      scenarioRunning = false;
+    }
+    return report;
+  };
+  const room = {
+    world,
+    renderer,
+    scene,
+    camera,
+    arsenal,
+    fluids,
+    fluidRenderer: fluidView,
+    log,
+    get tool() {
+      return tool;
+    },
+    get scenarios() {
+      return allScenarios();
+    },
+    spawn,
+    clear,
+    resetAll,
+    setTool,
+    useItem,
+    use(hold = 0) {
+      if (tool.def.category === "hand") {
+        grab();
+        return;
+      }
+      useTool(FIXED_DT, false);
+      flush();
+      let t0 = 0;
+      while (t0 < hold) {
+        useTool(FIXED_DT, true);
+        stepSim(FIXED_DT);
+        t0 += FIXED_DT;
+      }
+      tool.release();
+    },
+    grab,
+    throwHeld,
+    look(position, target) {
+      player.look(position, target);
+    },
+    inspect() {
+      const r = inspectTarget();
+      if (!r) return null;
+      return { objectId: r.object, partId: r.part, itemId: entryOf(r.object)?.so.itemId ?? "" };
+    },
+    inspectInfo,
+    spawned() {
+      return [...entries.values()].filter((e) => !e.arena).map((e) => e.so);
+    },
+    update,
+    on(type, fn) {
+      listeners[type].add(fn);
+      return () => listeners[type].delete(fn);
+    },
+    runScenarios,
+    tilt(rad) {
+      heldTilt = rad;
+    },
+    toggleTap,
+    setSlowMotion(on) {
+      timeScale = on ? 0.25 : 1;
+    },
+    setFastForward(on) {
+      fastForward = on;
+    },
+    equip,
+    loadModule,
+    animations: animationsOf,
+    playAnimation,
+    dispose() {
+      cancelAnimationFrame?.(raf);
+      window.removeEventListener("resize", onResize);
+      player.dispose();
+      ui?.dispose();
+      renderer.dispose();
+      fluidView.dispose();
+      for (const tr of tracers) tr.line.removeFromParent();
+      clearProjectileMeshes();
+      if (ownRenderer) {
+        gl.dispose();
+        dom.remove();
+      }
+    }
+  };
+  let ui = null;
+  if (options.ui !== false) {
+    const groups = () => {
+      const m = /* @__PURE__ */ new Map();
+      for (const i of catalog) {
+        const g = m.get(i.group) ?? [];
+        g.push(i);
+        m.set(i.group, g);
+      }
+      return m;
+    };
+    ui = createUi({
+      container,
+      strings: S,
+      t,
+      log,
+      groups,
+      loadout: () => loadout.map((id) => ({ id, name: arsenal.name(id) })),
+      onSpawn: (id) => {
+        spawn(id);
+      },
+      onEquip: (itemId) => {
+        const w = catalogMap.get(itemId)?.weapon;
+        if (w) equip(w);
+      },
+      onClear: clear,
+      onResetAll: resetAll,
+      onSlow: (on) => room.setSlowMotion(on),
+      onFast: (on) => room.setFastForward(on),
+      onQuality: (q) => {
+        qualityName = q;
+        if (ownRenderer) {
+          gl.shadowMap.enabled = q !== "low";
+          gl.setPixelRatio(q === "low" ? 1 : Math.min(typeof devicePixelRatio === "number" ? devicePixelRatio : 1, 2));
+          arena.sun.shadow.mapSize.set(q === "high" ? 2048 : 1024, q === "high" ? 2048 : 1024);
+          arena.sun.shadow.map?.dispose();
+          arena.sun.shadow.map = null;
+          resize();
+        }
+      },
+      quality: qualityName,
+      scenarios: allScenarios,
+      onRun: async (sc) => {
+        await runScenarios([sc]);
+      },
+      onRunAll: async () => {
+        await runScenarios();
+      },
+      onTool: (index) => {
+        toolIndex = index;
+        setTool(loadout[index]);
+      },
+      onTap: () => toggleTap(),
+      onPlay: (objectId, clipId) => {
+        playAnimation(clipId, objectId);
+      },
+      onResize: resize
+    });
+    ui.hud(hudState());
+  }
+  let raf = 0;
+  if (ownRenderer && typeof requestAnimationFrame === "function") {
+    let last = performance.now();
+    const loop = (now) => {
+      raf = requestAnimationFrame(loop);
+      const dt = Math.min(0.05, (now - last) / 1e3);
+      last = now;
+      if (!scenarioRunning) update(dt);
+      gl.render(scene, camera);
+    };
+    raf = requestAnimationFrame(loop);
+  }
+  if (options.initial) {
+    for (const [i, id] of options.initial.entries()) spawn(id, [(i - (options.initial.length - 1) / 2) * 1.3, 0, 0.5]);
+  }
+  return room;
+}
+function structuredCloneSpec(spec) {
+  return JSON.parse(JSON.stringify(spec));
+}
+export {
+  DEMO_ITEMS,
+  DEMO_MATERIALS,
+  MATERIAL_COLORS,
+  SCENARIOS,
+  brickWallSpec,
+  buildFromSpec,
+  createLog,
+  createTestRoom,
+  demoItems,
+  locales,
+  makeScenarios,
+  resolveStrings,
+  scenariosFor
+};
+//# sourceMappingURL=index.js.map