@adatechnology/game-test-room 0.17.1 → 0.19.0

package/dist/index.js

@@ -5,9 +5,9 @@ import { createDestructionRenderer, createDestructionSound, dragSoundKey, impact
 import { createArsenal, DEFAULT_LOADOUT } from "@adatechnology/game-weapons";
 import { createFilmLcg, createFluids, createItemUse, ITEM_USES, resolveStrings as resolveFluidStrings } from "@adatechnology/game-fluids";
 import { createFilmBridge, createFilmManager, createFluidRenderer } from "@adatechnology/game-fluids-three";
-import { createVfx } from "@adatechnology/game-vfx";
+import { SPRITE_KINDS, createVfx, patchSpriteKinds } from "@adatechnology/game-vfx";
 import { createVfxRenderer } from "@adatechnology/game-vfx-three";
-import { checkAnimation, checkBench, checkDestructible, checkSpec, createEnvironmentBus, shotExtras, useToHit } from "@adatechnology/game-contracts";
+import { checkAnimation, checkBench, checkDestructible, checkSpec, createEnvironmentBus, sealBlock, sealOpener, shotExtras, twistStroke, TWIST_LIFT, useToHit } from "@adatechnology/game-contracts";
 
 // src/arena.ts
 import { markKitOrigin } from "@adatechnology/game-contracts";
@@ -110,7 +110,7 @@ function resolveScenery(scenery) {
     if (!position) throw new Error(`game-test-room: scenery "${id}" is new, so it needs a position`);
     merged.set(id, { ...obj, position });
   }
-  return [...merged.entries()].map(([id, o]) => ({ id, spec: o.spec, position: o.position, rotationY: o.rotationY ?? 0, colors: o.colors, build: o.build, follow: o.follow, label: o.label, top: o.top, spout: o.spout, free: o.free }));
+  return [...merged.entries()].map(([id, o]) => ({ id, spec: o.spec, position: o.position, rotationY: o.rotationY ?? 0, colors: o.colors, build: o.build, follow: o.follow, label: o.label, top: o.top, spout: o.spout, free: o.free, pushable: o.pushable }));
 }
 function createArena(THREE, size, scene, scenery, tapOption) {
   const group = markKitOrigin(new THREE.Group(), { owner: "game-test-room", kind: "room" });
@@ -435,8 +435,8 @@ function buildFromSpec(THREE, spec, options = {}) {
   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);
+    const key2 = `${p.material}:${color}`;
+    let m = mats.get(key2);
     if (!m) {
       const alpha = TRANSPARENT[p.material];
       const metal = p.material === "steel" || p.material === "aluminium" || p.material === "copper" || p.material === "cast_iron";
@@ -448,7 +448,7 @@ function buildFromSpec(THREE, spec, options = {}) {
         opacity: alpha ?? 1,
         depthWrite: !alpha
       });
-      mats.set(key, m);
+      mats.set(key2, m);
     }
     return m;
   };
@@ -569,8 +569,8 @@ function createExplosives(context) {
       age: 0,
       ...use.explosive !== void 0 ? { body: createExplosiveBody(use, arsenal.explosives, arsenal.rules.explosives), aligned: isRocket } : {}
     });
-    const key = isRocket ? "act.launch" : isMolotov ? "act.throw.molotov" : "act.throw.grenade";
-    action(isRocket ? "launch_projectile" : "throw_projectile", translate(key, { weapon: context.toolName(), fuse: format(use.fuse, 1), arm: format(use.armDistance ?? 0, 0) }), {
+    const key2 = isRocket ? "act.launch" : isMolotov ? "act.throw.molotov" : "act.throw.grenade";
+    action(isRocket ? "launch_projectile" : "throw_projectile", translate(key2, { weapon: context.toolName(), fuse: format(use.fuse, 1), arm: format(use.armDistance ?? 0, 0) }), {
       data: { weapon: context.toolId(), fuse: use.fuse, explosive: use.explosive }
     });
   };
@@ -1229,9 +1229,9 @@ function createLog(options = {}) {
   };
   const log = {
     add,
-    coalesce(key, entry, windowS = 1) {
+    coalesce(key2, entry, windowS = 1) {
       const now = entry.t ?? clock();
-      const k = keyed.get(key);
+      const k = keyed.get(key2);
       if (k && now - k.last <= windowS && list.includes(k.entry)) {
         const { t: _t, ...rest } = entry;
         k.count++;
@@ -1242,7 +1242,7 @@ function createLog(options = {}) {
         return k.entry;
       }
       const e = add(entry);
-      keyed.set(key, { entry: e, last: now, count: 1 });
+      keyed.set(key2, { entry: e, last: now, count: 1 });
       return e;
     },
     setBeforeRead(fn) {
@@ -1378,7 +1378,7 @@ function createNarrator(c) {
     if (p) materialMemo.set(`${objectId}|${partId}`, p.material);
     return p;
   };
-  const plural = (key, n) => t(`${key}.${n === 1 ? "one" : "other"}`, { n });
+  const plural = (key2, n) => t(`${key2}.${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) });
@@ -1442,18 +1442,18 @@ function createNarrator(c) {
         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 };
+          const key2 = `${ev.object}|${lost}`;
+          const g = lostJoints.get(key2) ?? { obj: ev.object, part: lost, joints: 0, groups: 0, merged: false };
           g.joints++;
           g.groups = ev.groups.length;
-          lostJoints.set(key, g);
+          lostJoints.set(key2, 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 key2 = `${ev.object}|${ev.by}`;
+          const g = openJoints.get(key2) ?? { 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);
+          openJoints.set(key2, g);
         }
       } else if (ev.type === "ignite") {
         const g = fireParts.get(ev.object) ?? { obj: ev.object, parts: [], temp: 0, done: false };
@@ -1466,14 +1466,14 @@ function createNarrator(c) {
         outParts.set(ev.object, g);
       }
     }
-    const lostTail = (key) => {
-      const g = lostJoints.get(key);
+    const lostTail = (key2) => {
+      const g = lostJoints.get(key2);
       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);
+    const lostData = (key2) => {
+      const g = lostJoints.get(key2);
       return g ? { jointsOpened: g.joints, pieces: g.groups } : {};
     };
     for (const ev of batch) {
@@ -1597,8 +1597,8 @@ function createNarrator(c) {
           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);
+            const key3 = `${ev.object}|${lost}`;
+            const g2 = lostJoints.get(key3);
             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;
@@ -1609,12 +1609,12 @@ function createNarrator(c) {
               ...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) }
+              data: { parts: [a2, b2], by: ev.by, ...lostData(key3) }
             });
             break;
           }
-          const key = `${ev.object}|${ev.by}`;
-          const g = openJoints.get(key);
+          const key2 = `${ev.object}|${ev.by}`;
+          const g = openJoints.get(key2);
           if (!g || g.done) break;
           g.done = true;
           const [a, b] = ev.parts;
@@ -1767,13 +1767,13 @@ function createNarrator(c) {
   };
   const kindMemo = /* @__PURE__ */ new Map();
   const kindOf = (objectId, jointId) => {
-    const key = `${objectId}|${jointId}`;
+    const key2 = `${objectId}|${jointId}`;
     const own = c.world.state(objectId)?.joints.find((j) => j.id === jointId)?.kind;
     if (own) {
-      kindMemo.set(key, own);
+      kindMemo.set(key2, own);
       return own;
     }
-    const known = kindMemo.get(key);
+    const known = kindMemo.get(key2);
     if (known) return known;
     for (const id of c.world.ids()) {
       const k = c.world.state(id)?.joints.find((j) => j.id === jointId)?.kind;
@@ -1809,6 +1809,7 @@ function createNarrator(c) {
         break;
       }
       case "drink": {
+        if (ev.eaten) break;
         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 };
@@ -1842,12 +1843,12 @@ function createNarrator(c) {
         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 key2 = `stain:${ev.liquid}:${ev.surface}`;
+        const acc = stainAcc.get(key2);
         const n = acc && c.now() - acc.last <= 1 ? acc.n + 1 : 1;
-        stainAcc.set(key, { n, last: c.now() });
+        stainAcc.set(key2, { n, last: c.now() });
         c.log.coalesce(
-          key,
+          key2,
           {
             channel: "event",
             type: f + "stain",
@@ -1860,13 +1861,13 @@ function createNarrator(c) {
       }
       case "dried": {
         const info = stainInfo.get(ev.stain);
-        const key = `dried:${info?.liquid ?? "?"}:${ev.mark}`;
-        const acc = driedAcc.get(key);
+        const key2 = `dried:${info?.liquid ?? "?"}:${ev.mark}`;
+        const acc = driedAcc.get(key2);
         const n = acc && c.now() - acc.last <= 1.5 ? acc.n + 1 : 1;
-        driedAcc.set(key, { n, last: c.now() });
+        driedAcc.set(key2, { 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);
+        c.log.coalesce(key2, { channel: "event", type: f + "dried", text, data: { stain: ev.stain, mark: ev.mark, count: n } }, 1.5);
         break;
       }
       case "mix":
@@ -1979,6 +1980,7 @@ function createPlayer(THREE, o) {
   let useStarted = false;
   let holdTimer = null;
   let walkHeld = false;
+  let seated = false;
   let lookLimit = null;
   const look = (dx, dy) => {
     yaw -= dx * LOOK;
@@ -2119,6 +2121,11 @@ function createPlayer(THREE, o) {
     setWalkHeld(held) {
       walkHeld = held;
     },
+    setSeated(value) {
+      seated = value;
+      y = 0;
+      vy = 0;
+    },
     setBend(metres) {
       bendTarget = metres;
     },
@@ -2171,6 +2178,11 @@ function createPlayer(THREE, o) {
       if ((walkX || walkZ) && !walkHeld) move(walkX * speed * dt, walkZ * speed * dt);
       walked = dt > 0 ? Math.hypot(px.x - fromX, px.z - fromZ) / dt : 0;
       running = run && walked > 0;
+      if (seated) {
+        followFloor(dt);
+        apply();
+        return;
+      }
       const floor = Math.max(floorHere(), o.footing?.(px.x, px.z, PLAYER_RADIUS * FOOT, y).floor ?? -Infinity);
       if (y < floor && vy <= 0) y = floor;
       if (y <= floor && keys.has("Space") && !walkHeld) vy = JUMP;
@@ -2318,7 +2330,7 @@ function createRoomPush(options) {
     }
     control.release();
     player.setWalkHeld(false);
-    player.setBend(0);
+    if (!options.hasBody?.()) player.setBend(0);
     player.setLookLimit(null);
     options.ring(null);
     event("release", lean);
@@ -2380,7 +2392,7 @@ function createRoomPush(options) {
       control.begin(material === void 0 ? { massKg } : { massKg, material });
       dragged = 0;
       player.setWalkHeld(true);
-      if (isLow) player.setBend(Math.min(MAX_BEND, Math.max(0, STANDING_EYE - (max[1] - player.feet + LOW_EYE_OVER_TOP))));
+      if (isLow && !options.hasBody?.()) player.setBend(Math.min(MAX_BEND, Math.max(0, STANDING_EYE - (max[1] - player.feet + LOW_EYE_OVER_TOP))));
       player.setLookLimit({ yaw: Math.atan2(-into[0], -into[1]), range: LOOK_RANGE });
       event("grip", leaning);
       return true;
@@ -2440,6 +2452,501 @@ function createRoomPush(options) {
   };
 }
 
+// src/seating.ts
+var SIT_EYE = 0.62;
+var LIE_EYE = 0.18;
+var STANDING_EYE2 = 1.7;
+var LOOK_RANGE2 = 1.6;
+function createSeating(o) {
+  const { THREE, player } = o;
+  const v = new THREE.Vector3();
+  const q = new THREE.Quaternion();
+  const e = new THREE.Euler();
+  let current = null;
+  let facing = 0;
+  const toWorld = (root, local) => {
+    root.updateWorldMatrix(true, false);
+    v.set(local[0], local[1], local[2]).applyMatrix4(root.matrixWorld);
+    return [v.x, v.y, v.z];
+  };
+  const yawOf = (root) => {
+    root.getWorldQuaternion(q);
+    return e.setFromQuaternion(q, "YXZ").y;
+  };
+  const nearest = (holder) => {
+    let best;
+    let bestDistance = Infinity;
+    for (const seat of holder.seats) {
+      const [x, , z] = toWorld(holder.root, seat.pos);
+      const distance = Math.hypot(x - player.x, z - player.z);
+      if (distance < bestDistance) {
+        best = seat;
+        bestDistance = distance;
+      }
+    }
+    return best;
+  };
+  const hold = () => {
+    player.setSeated(true);
+    player.setWalkHeld(true);
+    player.setLookLimit({ yaw: facing, range: LOOK_RANGE2 });
+  };
+  const release = () => {
+    player.setSeated(false);
+    player.setWalkHeld(false);
+    player.setLookLimit(null);
+    current = null;
+  };
+  const seating = {
+    sit(objectId, seatId) {
+      const holder = objectId ? o.find(objectId) : o.pick();
+      if (!holder) return null;
+      const seat = seatId ? holder.seats.find((s) => s.id === seatId) : nearest(holder);
+      if (!seat) return null;
+      const [x, y, z] = toWorld(holder.root, seat.pos);
+      const eye = o.hasBody?.() ? STANDING_EYE2 : seat.eye ?? (seat.pose === "lie" ? LIE_EYE : SIT_EYE);
+      facing = yawOf(holder.root) + seat.ry + Math.PI;
+      player.setPose([x, y + eye, z], facing, 0);
+      current = { objectId: holder.objectId, seatId: seat.id, pose: seat.pose, hips: [x, y, z] };
+      hold();
+      o.onSit?.(current);
+      return current;
+    },
+    stand() {
+      if (!current) return false;
+      const holder = o.find(current.objectId);
+      const seat = holder?.seats.find((s) => s.id === current?.seatId);
+      if (holder && seat) {
+        const [x, , z] = toWorld(holder.root, seat.exit);
+        if (!player.canStand(x, z)) return false;
+        player.setPose([x, o.groundAt(x, z) + STANDING_EYE2, z], player.yaw, 0);
+      } else player.setPose([player.x, o.groundAt(player.x, player.z) + STANDING_EYE2, player.z], player.yaw, 0);
+      const left = current;
+      release();
+      o.onStand?.(left);
+      return true;
+    },
+    update() {
+      if (!current) return;
+      if (!o.find(current.objectId)) {
+        seating.stand();
+        return;
+      }
+      const [walkX, walkZ] = player.walkIntent;
+      if (walkX || walkZ || player.keys.has("Space")) {
+        seating.stand();
+        return;
+      }
+      hold();
+    },
+    release,
+    get seat() {
+      return current;
+    }
+  };
+  return seating;
+}
+
+// src/door-open.ts
+import { createDoorUse, DOOR_USE_DEFAULTS } from "@adatechnology/game-player";
+var DOOR_REACH = 2.2;
+var NEAR_LEAF = 0.25;
+var NEAR_OPEN_LEAF = 0.9;
+var BODY_HEIGHT = 1.8;
+var HAND_REST = [0.22, -0.42, -0.32];
+var SKIN = 0.01;
+var HANDLE_INSET = 0.06;
+var STANDOFF2 = 0.55;
+var DRAWER_TRAVEL = 0.3;
+var CLEAR_OF_ARC = 0.3;
+var OUT_IN_FRONT = 0.42;
+var ARRIVED = 0.05;
+var TURN_RATE = 8;
+var MAX_WALK_SECONDS = 1.5;
+var APPROACH_SPEED2 = 3;
+var FLOOR_GAP = 0.03;
+var key = (objectId, part) => `${objectId}\0${part}`;
+var slides = (clip, part) => {
+  const last = clip.keys[clip.keys.length - 1]?.parts?.[part];
+  const r = last?.rotation ?? [0, 0, 0];
+  return Math.abs(r[0]) + Math.abs(r[1]) + Math.abs(r[2]) < 1e-3;
+};
+function createRoomDoors(options) {
+  const { THREE, player, world, camera, arena } = options;
+  const control = createDoorUse(options.rules);
+  const openings = /* @__PURE__ */ new Map();
+  const box2 = new THREE.Box3();
+  const before = new THREE.Box3();
+  const tmp = new THREE.Vector3();
+  const centre = new THREE.Vector3();
+  let using = null;
+  let reaching = null;
+  const rules = { ...DOOR_USE_DEFAULTS, ...options.rules };
+  const holding = () => {
+    if (reaching) {
+      const h = reaching.reach.handle();
+      return { phase: reaching.phase, progress: reaching.progress, at: new THREE.Vector3(h[0], h[1], h[2]), pull: reaching.reach.pull ?? true };
+    }
+    if (!using || control.phase === "idle") return null;
+    using.obj.updateMatrixWorld(true);
+    return { phase: control.phase, progress: using.progress, at: using.obj.localToWorld(new THREE.Vector3().copy(using.grip)), pull: using.pull };
+  };
+  const standFor = (handle, hinge, slide) => {
+    if (!hinge || slide) {
+      const dx = handle.x - player.x;
+      const dz = handle.z - player.z;
+      const d = Math.hypot(dx, dz) || 1;
+      const off = slide ? STANDOFF2 + DRAWER_TRAVEL : STANDOFF2;
+      return [handle.x - dx / d * off, handle.z - dz / d * off];
+    }
+    let ax = handle.x - hinge.x;
+    let az = handle.z - hinge.z;
+    const width = Math.hypot(ax, az);
+    if (width < 0.05) return standFor(handle, null, false);
+    ax /= width;
+    az /= width;
+    let nx = -az;
+    let nz = ax;
+    if ((player.x - handle.x) * nx + (player.z - handle.z) * nz < 0) {
+      nx = -nx;
+      nz = -nz;
+    }
+    const x = hinge.x + ax * (width + CLEAR_OF_ARC) + nx * OUT_IN_FRONT;
+    const z = hinge.z + az * (width + CLEAR_OF_ARC) + nz * OUT_IN_FRONT;
+    return player.canStand(x, z) ? [x, z] : standFor(handle, null, false);
+  };
+  const face = (handle, dt) => {
+    camera.updateMatrixWorld(true);
+    const eye = camera.getWorldPosition(new THREE.Vector3());
+    const dx = handle.x - player.x;
+    const dz = handle.z - player.z;
+    const flat = Math.hypot(dx, dz);
+    if (flat < 0.05) return;
+    const yaw = Math.atan2(-dx, -dz);
+    const pitch = Math.atan2(handle.y - eye.y, flat);
+    let dYaw = yaw - player.yaw;
+    dYaw = Math.atan2(Math.sin(dYaw), Math.cos(dYaw));
+    const k = Math.min(1, dt * TURN_RATE);
+    player.setPose([player.x, eye.y, player.z], player.yaw + dYaw * k, player.pitch + (pitch - player.pitch) * k);
+  };
+  const approach = (handle, hinge, slide, dt, walked) => {
+    const [x, z] = standFor(handle, hinge, slide);
+    const dx = x - player.x;
+    const dz = z - player.z;
+    const d = Math.hypot(dx, dz);
+    if (d < ARRIVED || walked > MAX_WALK_SECONDS) return true;
+    const go = Math.min(d, APPROACH_SPEED2 * dt);
+    if (go < 1e-4) return false;
+    const x0 = player.x;
+    const z0 = player.z;
+    player.moveBy(dx / d * go, dz / d * go);
+    return Math.hypot(player.x - x0, player.z - z0) < go * 0.2;
+  };
+  const openingOf = (objectId, part) => openings.get(key(objectId, part)) ?? 0;
+  const lastGoals = /* @__PURE__ */ new Map();
+  const leafAt = (objectId, part, point) => {
+    const leaves = options.leaves(objectId);
+    if (leaves.length === 0) return null;
+    const exact = leaves.find((l) => l.part === part);
+    if (exact) return exact;
+    let best = null;
+    let bestD = NEAR_LEAF;
+    let open = null;
+    let openD = NEAR_OPEN_LEAF;
+    for (const l of leaves) {
+      const obj = options.objectOf(objectId, l.part);
+      if (!obj) continue;
+      box2.setFromObject(obj);
+      const d = box2.distanceToPoint(tmp.set(point[0], point[1], point[2]));
+      if (d < bestD) {
+        bestD = d;
+        best = l;
+      }
+      if (openingOf(objectId, l.part) > 0.5 && d < openD) {
+        openD = d;
+        open = l;
+      }
+    }
+    return best ?? open;
+  };
+  const picked = () => {
+    for (const hit of options.pick()) {
+      const leaf = leafAt(hit.objectId, hit.part, hit.point);
+      if (leaf) return { hit, leaf };
+    }
+    return null;
+  };
+  const massOf = (objectId, part) => world.part(objectId, part)?.mass ?? 10;
+  const event = (type, u, by) => options.onEvent({ type, objectId: u.objectId, part: u.leaf.part, name: options.nameOf(u.objectId), opening: openingOf(u.objectId, u.leaf.part), ...by ? { by } : {} });
+  const overlaps2d = (b, c) => b.max.x > c[0] && b.min.x < c[2] && b.max.z > c[1] && b.min.z < c[3];
+  const bodyOverlap = (b) => {
+    if (b.min.y > player.feet + BODY_HEIGHT || b.max.y < player.feet + 0.05) return null;
+    const cx = Math.max(b.min.x, Math.min(b.max.x, player.x));
+    const cz = Math.max(b.min.z, Math.min(b.max.z, player.z));
+    const dx = player.x - cx;
+    const dz = player.z - cz;
+    const d = Math.hypot(dx, dz);
+    if (d >= PLAYER_RADIUS) return null;
+    if (d < 1e-4) {
+      const outs = [
+        [b.max.x - player.x, 1, 0],
+        [player.x - b.min.x, -1, 0],
+        [b.max.z - player.z, 0, 1],
+        [player.z - b.min.z, 0, -1]
+      ];
+      outs.sort((a, c) => a[0] - c[0]);
+      const o = outs[0];
+      return [o[1] * (o[0] + PLAYER_RADIUS), o[2] * (o[0] + PLAYER_RADIUS)];
+    }
+    const push = PLAYER_RADIUS - d + SKIN;
+    return [dx / d * push, dz / d * push];
+  };
+  const isFree = (u, from, to) => {
+    const { objectId, leaf, obj } = u;
+    obj.updateMatrixWorld(true);
+    before.setFromObject(obj);
+    options.pose(objectId, leaf.part, leaf.clip, to);
+    obj.updateMatrixWorld(true);
+    box2.setFromObject(obj);
+    box2.expandByScalar(-SKIN);
+    let by = null;
+    if (Math.max(Math.abs(box2.min.x), Math.abs(box2.max.x), Math.abs(box2.min.z), Math.abs(box2.max.z)) > arena.limit) by = "wall";
+    else
+      for (let i = 0; i < arena.colliders.length; i++) {
+        const c = arena.colliders[i];
+        if (arena.ids[i] === objectId) continue;
+        if (overlaps2d(box2, c) && !overlaps2d(before, c)) {
+          by = arena.ids[i] ?? "wall";
+          break;
+        }
+      }
+    if (!by) {
+      before.getCenter(centre);
+      box2.getCenter(tmp);
+      const dir = [tmp.x - centre.x, tmp.y - centre.y, tmp.z - centre.z];
+      const len = Math.hypot(dir[0], dir[1], dir[2]);
+      if (len > 1e-5) {
+        const hit = world.sweepBox({ min: [before.min.x + SKIN, before.min.y + FLOOR_GAP, before.min.z + SKIN], max: [before.max.x - SKIN, before.max.y - SKIN, before.max.z - SKIN] }, dir, len * 2, { ignore: objectId, spacing: 0.12 });
+        if (hit && hit.normal[1] < 0.7) by = hit.object;
+      }
+    }
+    if (!by) {
+      const out = bodyOverlap(box2);
+      if (out) {
+        const x0 = player.x;
+        const z0 = player.z;
+        player.moveBy(out[0], out[1]);
+        if (Math.hypot(player.x - x0, player.z - z0) < Math.hypot(out[0], out[1]) * 0.5) by = "player";
+        else if (u.phase !== "swing" || from === 0) event("stepped_back", u);
+      }
+    }
+    if (by) {
+      options.pose(objectId, leaf.part, leaf.clip, from);
+      const at = [box2.getCenter(tmp).x, tmp.y, tmp.z];
+      options.sound(options.impactKey(objectId, leaf.part), at, Math.min(0.6, 0.15 + massOf(objectId, leaf.part) * 0.02));
+      event("blocked", u, by);
+      return false;
+    }
+    return true;
+  };
+  const handleOf = (obj, leaf, point) => {
+    obj.updateMatrixWorld(true);
+    box2.setFromObject(obj);
+    const lo = new THREE.Vector3(Infinity, Infinity, Infinity);
+    const hi = new THREE.Vector3(-Infinity, -Infinity, -Infinity);
+    for (let i = 0; i < 8; i++) {
+      tmp.set(i & 1 ? box2.max.x : box2.min.x, i & 2 ? box2.max.y : box2.min.y, i & 4 ? box2.max.z : box2.min.z);
+      obj.worldToLocal(tmp);
+      lo.min(tmp);
+      hi.max(tmp);
+    }
+    const aimed = point ? obj.worldToLocal(new THREE.Vector3(point[0], point[1], point[2])) : lo.clone().add(hi).multiplyScalar(0.5);
+    if (!point) {
+      const local = obj.worldToLocal(obj.getWorldPosition(new THREE.Vector3()).setY(player.feet + 1));
+      aimed.y = local.y;
+    }
+    aimed.clamp(lo, hi);
+    if (slides(leaf.clip, leaf.part)) return aimed;
+    const last = leaf.clip.keys[leaf.clip.keys.length - 1]?.parts?.[leaf.part]?.rotation ?? [0, 1, 0];
+    const axis = Math.abs(last[0]) >= Math.abs(last[1]) && Math.abs(last[0]) >= Math.abs(last[2]) ? 0 : Math.abs(last[1]) >= Math.abs(last[2]) ? 1 : 2;
+    const size = [hi.x - lo.x, hi.y - lo.y, hi.z - lo.z];
+    const reachOf = (k) => Math.max(Math.abs(lo.getComponent(k)), Math.abs(hi.getComponent(k)));
+    let across = -1;
+    for (let k = 0; k < 3; k++) {
+      if (k === axis || size[k] < Math.min(size[0], size[1], size[2]) + 1e-6) continue;
+      if (across < 0 || reachOf(k) > reachOf(across)) across = k;
+    }
+    if (across < 0) return aimed;
+    const far = Math.abs(hi.getComponent(across)) >= Math.abs(lo.getComponent(across)) ? hi.getComponent(across) : lo.getComponent(across);
+    aimed.setComponent(across, far - Math.sign(far) * Math.min(HANDLE_INSET, size[across] * 0.25));
+    return aimed;
+  };
+  const start = (objectId, leaf, point) => {
+    reaching = null;
+    const obj = options.objectOf(objectId, leaf.part);
+    if (!obj) return false;
+    if (using && (using.objectId !== objectId || using.leaf.part !== leaf.part)) control.cancel();
+    obj.updateMatrixWorld(true);
+    const grip = handleOf(obj, leaf, point);
+    const opening = openingOf(objectId, leaf.part);
+    const key2 = `${objectId}|${leaf.part}`;
+    const lastGoal = lastGoals.get(key2);
+    const goal = control.begin({ opening, massKg: massOf(objectId, leaf.part), locked: options.isLocked(objectId, leaf.part), ...lastGoal !== void 0 ? { lastGoal } : {} });
+    if (goal !== null) lastGoals.set(key2, goal);
+    let pull = true;
+    if (goal !== null) {
+      obj.updateMatrixWorld(true);
+      options.pose(objectId, leaf.part, leaf.clip, 1);
+      obj.updateMatrixWorld(true);
+      const openAt = obj.localToWorld(grip.clone());
+      options.pose(objectId, leaf.part, leaf.clip, 0);
+      obj.updateMatrixWorld(true);
+      const shutAt = obj.localToWorld(grip.clone());
+      options.pose(objectId, leaf.part, leaf.clip, opening);
+      const dOpen = Math.hypot(openAt.x - player.x, openAt.z - player.z);
+      const dShut = Math.hypot(shutAt.x - player.x, shutAt.z - player.z);
+      pull = goal === 1 ? dOpen <= dShut : dShut <= dOpen;
+    }
+    using = { objectId, leaf, obj, grip, pull, phase: control.phase, progress: 0, walked: 0, there: goal === null };
+    const at = obj.localToWorld(grip.clone());
+    if (goal === null) {
+      options.sound("leaf_rattle", [at.x, at.y, at.z], 0.6);
+      event("locked", using);
+    } else event("reach", using);
+    return true;
+  };
+  return {
+    get active() {
+      return reaching !== null || using !== null && control.phase !== "idle";
+    },
+    get state() {
+      return using ? { objectId: using.objectId, part: using.leaf.part, phase: control.phase, opening: openingOf(using.objectId, using.leaf.part), goal: control.goal } : null;
+    },
+    get avatarState() {
+      const h = holding();
+      return h ? { phase: h.phase, progress: h.progress, height: h.at.y - player.feet, pull: h.pull } : null;
+    },
+    aimed() {
+      const found = picked();
+      if (!found) return null;
+      const { hit, leaf } = found;
+      return { objectId: hit.objectId, part: leaf.part, open: openingOf(hit.objectId, leaf.part) > 0.5, locked: options.isLocked(hit.objectId, leaf.part) };
+    },
+    use() {
+      const found = picked();
+      return found ? start(found.hit.objectId, found.leaf, found.hit.point) : false;
+    },
+    useLeaf(objectId, part) {
+      const leaves = options.leaves(objectId);
+      const leaf = part === void 0 ? leaves[0] : leaves.find((l) => l.part === part);
+      return leaf ? start(objectId, leaf, null) : false;
+    },
+    opening: openingOf,
+    step(dt) {
+      const r = reaching;
+      if (r) {
+        r.time += dt;
+        if (r.phase === "reach" && !r.there) {
+          const h = r.reach.handle();
+          const hinge = r.reach.hinge?.();
+          r.walked += dt;
+          const g = new THREE.Vector3(h[0], h[1], h[2]);
+          r.there = approach(g, hinge ? new THREE.Vector3(hinge[0], hinge[1], hinge[2]) : null, false, dt, r.walked);
+          face(g, dt);
+          if (r.there) r.time = 0;
+        } else if (r.phase === "reach") {
+          r.progress = Math.min(1, r.time / rules.reachSeconds);
+          if (r.progress >= 1) {
+            r.reach.onGrip?.();
+            r.phase = r.reach.locked ? "rattle" : "swing";
+            r.time = 0;
+            r.progress = 0;
+          }
+        } else if (r.phase === "swing" || r.phase === "rattle") {
+          r.progress = Math.min(1, r.time / (r.phase === "rattle" ? rules.rattleSeconds : Math.max(0.05, r.reach.seconds)));
+          if (r.progress >= 1) {
+            r.phase = "release";
+            r.time = 0;
+            r.progress = 0;
+          }
+        } else {
+          r.progress = Math.min(1, r.time / rules.releaseSeconds);
+          if (r.progress >= 1) reaching = null;
+        }
+        return;
+      }
+      const u = using;
+      if (!u || control.phase === "idle") return;
+      const was = openingOf(u.objectId, u.leaf.part);
+      const wasPhase = control.phase;
+      if (wasPhase === "reach" && !u.there) {
+        u.obj.updateMatrixWorld(true);
+        u.walked += dt;
+        const g = u.obj.localToWorld(new THREE.Vector3().copy(u.grip));
+        u.there = approach(g, u.obj.getWorldPosition(new THREE.Vector3()), slides(u.leaf.clip, u.leaf.part), dt, u.walked);
+        face(g, dt);
+        if (!u.there) return;
+      }
+      const s = control.step(dt, (from, to) => isFree(u, from, to));
+      u.phase = s.phase;
+      u.progress = s.progress;
+      openings.set(key(u.objectId, u.leaf.part), s.opening);
+      u.obj.updateMatrixWorld(true);
+      const at = u.obj.localToWorld(tmp.copy(u.grip));
+      const point = [at.x, at.y, at.z];
+      const slide = slides(u.leaf.clip, u.leaf.part);
+      const shut = options.impactKey(u.objectId, u.leaf.part).replace("impact_", "leaf_shut_");
+      if (wasPhase === "reach" && s.phase !== "reach") {
+        if (slide) options.sound("leaf_slide", point, 0.5);
+        else {
+          if (was < 0.02) options.sound("leaf_latch", point, 0.5);
+          options.sound(/metal|glass/.test(shut) ? "leaf_creak_metal" : "leaf_creak_wood", point, 0.35);
+        }
+      }
+      if (s.arrived) {
+        if (s.opening <= 0) {
+          options.sound(slide ? "leaf_slide" : shut, point, Math.min(1, 0.3 + massOf(u.objectId, u.leaf.part) * 0.03));
+          event("closed", u);
+        } else event("opened", u);
+      }
+      if (s.phase === "idle") using = null;
+    },
+    handTargets() {
+      const h = holding();
+      if (!h || h.phase === "rattle" && h.progress > 0.92) return null;
+      const { at, phase, progress } = h;
+      if (phase === "rattle") at.y += Math.sin(progress * 60) * 0.012;
+      camera.updateMatrixWorld(true);
+      const rest = camera.localToWorld(new THREE.Vector3(HAND_REST[0], HAND_REST[1], HAND_REST[2]));
+      const k = phase === "reach" ? progress : phase === "release" ? 1 - progress : 1;
+      const ease = k * k * (3 - 2 * k);
+      const pos = rest.lerp(at, ease);
+      const way = new THREE.Vector3(at.x - player.x, 0, at.z - player.z);
+      if (way.lengthSq() < 1e-6) way.set(-Math.sin(player.yaw), 0, -Math.cos(player.yaw));
+      way.normalize();
+      const down = new THREE.Vector3(0, -1, 0);
+      const back = new THREE.Vector3().crossVectors(down, way);
+      const q = new THREE.Quaternion().setFromRotationMatrix(new THREE.Matrix4().makeBasis(way, back, down));
+      const grip = phase === "reach" ? 0.15 + 0.75 * progress : phase === "release" ? 0.9 * (1 - progress) : 0.9;
+      return { R: { position: [pos.x, pos.y, pos.z], quaternion: [q.x, q.y, q.z, q.w] }, L: null, grip };
+    },
+    reachFor(reach) {
+      if (using) {
+        control.cancel();
+        using = null;
+      }
+      reaching = { reach, phase: "reach", time: 0, progress: 0, walked: 0, there: false };
+    },
+    forget(objectId) {
+      for (const k of [...openings.keys()]) if (k.startsWith(`${objectId}\0`)) openings.delete(k);
+      if (using?.objectId === objectId) {
+        control.cancel();
+        using = null;
+      }
+    }
+  };
+}
+
 // src/room.ts
 import { createTerrain, createTerrainImpl, DEFAULT_PROFILE } from "@adatechnology/game-terrain";
 import { createTerrainRenderer } from "@adatechnology/game-terrain-three";
@@ -2660,17 +3167,24 @@ var en = {
     "loading.open_area": "Opening {area}\u2026",
     "loading.spawn": "Building {name}\u2026",
     "act.loosened": "{name} was heavy but free: the blast moved it",
+    "act.came_apart": "{name} came apart: what stayed is loose and falls",
     "act.shoved": "{name} stands free: the shots moved it",
     "act.impact": "{name} hit {where} at {speed} m/s: {energy} J of blunt damage",
     "act.use_item": "{name}: {use}",
+    "act.open_with": "Opened {name} with {tool}",
+    "act.open_by_hand": "Opened {name} by hand",
+    "act.ate": "Ate {grams} g of {name}",
+    "act.ate_all": "Ate all of {name} ({grams} g): the packaging is empty",
     "act.tap.on": "Tap opened",
     "act.tap.off": "Tap closed",
     "use.drink": "drink",
     "use.sip": "sip",
     "use.chug": "chug",
+    "use.eat": "eat",
     "use.pour": "pour",
     "use.pour_out": "pour out",
     "use.open": "open",
+    "use.unscrew": "unscrew",
     "use.close": "close",
     "hud.reloading": "Reloading...",
     "hud.empty": "Empty",
@@ -2687,15 +3201,32 @@ var en = {
     "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.door_locked": "{name} is locked",
+    "hud.door_blocked": "{name} hits something and stops ({percent}% open)",
+    "hud.door_hint_open": "E: open",
+    "hud.door_hint_close": "E: close",
+    "hud.door_hint_locked": "Locked",
+    "act.door_reach": "reaches for the handle of {name}",
+    "act.door_opened": "opens {name}",
+    "act.door_closed": "closes {name}",
+    "act.door_blocked": "{name} hits something and stops at {percent}%",
+    "act.door_locked": "tries {name}: locked, it only rattles",
+    "act.door_stepped_back": "steps back out of the way of {name}",
     "hud.push_on": "Pushing {name}: W pushes, S pulls, let go of E to stop",
     "hud.push_too_heavy": "{name} does not budge ({kg} kg)",
     "hud.push_blocked": "{name} is stuck: there is something in the way",
     "act.push_grip": "leans on {name} ({kg} kg)",
     "act.push_engaged": "starts pushing {name} ({kg} kg)",
+    "act.sit": "sits on {name}",
+    "act.lie": "lies down on {name}",
+    "act.stand": "gets up from {name}",
     "act.push_too_heavy": "strains against {name}: {kg} kg is too much",
     "act.push_obstacle": "{name} hits something and locks",
     "act.push_release": "lets go of {name}",
     "hud.empty_container": "{name} is empty",
+    "hud.needs_opener": "Opening {name} needs {tools} (put one within reach or in the loadout)",
+    "hud.spoiled_hole": "{name}: the packaging is holed through, what is inside is contaminated; do not eat or drink it",
+    "hud.spoiled_leak": "{name} leaked: what is left is contaminated; do not eat or drink it",
     "hud.refused": "Wrong tool for the {kind}",
     "hud.drop": "drop",
     "hud.rotate": "rotate",
@@ -2984,17 +3515,24 @@ var ptBR = {
     "loading.open_area": "Abrindo {area}\u2026",
     "loading.spawn": "Montando {name}\u2026",
     "act.loosened": "{name} \xE9 pesado mas estava solto: a explos\xE3o o moveu",
+    "act.came_apart": "{name} se desmontou: o que ficou est\xE1 solto e cai",
     "act.shoved": "{name} estava solto no ch\xE3o: os tiros o moveram",
     "act.impact": "{name} bateu em {where} a {speed} m/s: {energy} J de dano de impacto",
     "act.use_item": "{name}: {use}",
+    "act.open_with": "Abriu {name} com {tool}",
+    "act.open_by_hand": "Abriu {name} com a m\xE3o",
+    "act.ate": "Comeu {grams} g de {name}",
+    "act.ate_all": "Comeu todo o conte\xFAdo de {name} ({grams} g): a embalagem ficou vazia",
     "act.tap.on": "Abriu a torneira",
     "act.tap.off": "Fechou a torneira",
     "use.drink": "beber",
     "use.sip": "golinho",
     "use.chug": "virar",
+    "use.eat": "comer",
     "use.pour": "despejar",
     "use.pour_out": "esvaziar",
     "use.open": "abrir",
+    "use.unscrew": "desenroscar",
     "use.close": "fechar",
     "hud.reloading": "Recarregando...",
     "hud.empty": "Sem muni\xE7\xE3o",
@@ -3011,15 +3549,32 @@ var ptBR = {
     "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.door_locked": "{name} est\xE1 trancado(a)",
+    "hud.door_blocked": "{name} bateu em algo e parou ({percent}% aberto)",
+    "hud.door_hint_open": "E: abrir",
+    "hud.door_hint_close": "E: fechar",
+    "hud.door_hint_locked": "Trancado",
+    "act.door_reach": "leva a m\xE3o \xE0 ma\xE7aneta de {name}",
+    "act.door_opened": "abre {name}",
+    "act.door_closed": "fecha {name}",
+    "act.door_blocked": "{name} bate em algo e para em {percent}%",
+    "act.door_locked": "tenta abrir {name}: trancado, s\xF3 chacoalha",
+    "act.door_stepped_back": "d\xE1 um passo para tr\xE1s para {name} passar",
     "hud.push_on": "Empurrando {name}: W empurra, S puxa, solte o E para parar",
     "hud.push_too_heavy": "{name} n\xE3o se mexe ({kg} kg)",
     "hud.push_blocked": "{name} travou: tem algo no caminho",
     "act.push_grip": "encosta em {name} ({kg} kg)",
     "act.push_engaged": "come\xE7a a empurrar {name} ({kg} kg)",
+    "act.sit": "senta em {name}",
+    "act.lie": "deita em {name}",
+    "act.stand": "levanta de {name}",
     "act.push_too_heavy": "faz for\xE7a contra {name}: {kg} kg \xE9 demais",
     "act.push_obstacle": "{name} bate em algo e trava",
     "act.push_release": "solta {name}",
     "hud.empty_container": "{name} est\xE1 vazio",
+    "hud.needs_opener": "Para abrir {name} precisa de {tools} (deixe um ao alcance ou no invent\xE1rio)",
+    "hud.spoiled_hole": "{name}: a embalagem furou, o conte\xFAdo est\xE1 contaminado; n\xE3o d\xE1 para comer nem beber",
+    "hud.spoiled_leak": "{name} vazou: o que sobrou est\xE1 contaminado; n\xE3o d\xE1 para comer nem beber",
     "hud.refused": "Ferramenta errada para {kind}",
     "hud.drop": "soltar",
     "hud.rotate": "girar",
@@ -3384,9 +3939,9 @@ function createBenchPanel(o) {
       hasRoom = rows.room.length > 0;
       syncDisplay();
       roomLine.textContent = rows.room.map((row) => `${row.name} ${row.text}`).join(" \xB7 ");
-      const key = rows.module.map((row) => `${row.id}:${row.ratio !== void 0}`).join("|");
-      if (key !== metricKey) {
-        metricKey = key;
+      const key2 = rows.module.map((row) => `${row.id}:${row.ratio !== void 0}`).join("|");
+      if (key2 !== metricKey) {
+        metricKey = key2;
         renderMetrics(rows.module);
       }
       for (const row of rows.module) {
@@ -3740,8 +4295,7 @@ function createUi(o) {
   logBtn(t("ui.download_txt"), () => o.log.download("txt"));
   logBtn(t("ui.clear_log"), () => {
     o.log.clear();
-    logBody.textContent = "";
-    nodes.clear();
+    rebuildLog();
   });
   logPanel.append(logTitle, logBar, logBody);
   const MAX_LINES = 200;
@@ -3754,29 +4308,59 @@ function createUi(o) {
     const tm = mk3("time", void 0, fmtTime(e.t));
     n.append(tm, document.createTextNode(e.text));
   };
-  const addNode = (e) => {
-    if (!filters[e.channel]) return;
+  let pendingAdds = [];
+  const pendingUpdates = /* @__PURE__ */ new Map();
+  let isLogStale = false;
+  const isLogVisible = () => !window.matchMedia?.("(max-width:980px)").matches || root.classList.contains("open");
+  const buildNode = (e) => {
     const n = mk3("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;
+    return n;
   };
   function rebuildLog() {
+    pendingAdds = [];
+    pendingUpdates.clear();
+    isLogStale = false;
     logBody.textContent = "";
     nodes.clear();
-    for (const e of o.log.entries().slice(-MAX_LINES * 3)) addNode(e);
+    const fragment = document.createDocumentFragment();
+    for (const e of o.log.entries().slice(-MAX_LINES * 3)) if (filters[e.channel]) fragment.appendChild(buildNode(e));
+    logBody.appendChild(fragment);
+    trimLog();
   }
-  const offLog = o.log.on((e, updated) => {
-    if (updated) {
-      const n = nodes.get(e.seq);
+  function trimLog() {
+    while (logBody.childElementCount > MAX_LINES) {
+      const oldest = nodes.keys().next();
+      if (oldest.done) break;
+      nodes.delete(oldest.value);
+      logBody.firstElementChild?.remove();
+    }
+    if (autoscroll) logBody.scrollTop = logBody.scrollHeight;
+  }
+  const flushLog = () => {
+    if (pendingAdds.length === 0 && pendingUpdates.size === 0) return;
+    if (!isLogVisible()) {
+      isLogStale = true;
+      pendingAdds = [];
+      pendingUpdates.clear();
+      return;
+    }
+    if (isLogStale) return rebuildLog();
+    const fragment = document.createDocumentFragment();
+    for (const e of pendingAdds.slice(-MAX_LINES)) if (filters[e.channel]) fragment.appendChild(buildNode(e));
+    pendingAdds = [];
+    logBody.appendChild(fragment);
+    for (const [seq, e] of pendingUpdates) {
+      const n = nodes.get(seq);
       if (n) fill(n, e);
-    } else addNode(e);
+    }
+    pendingUpdates.clear();
+    trimLog();
+  };
+  const offLog = o.log.on((e, updated) => {
+    if (updated) pendingUpdates.set(e.seq, e);
+    else pendingAdds.push(e);
   });
   const right = mk3("div", "tr-right");
   const cat = mk3("div", "tr-panel tr-cat");
@@ -3866,8 +4450,8 @@ function createUi(o) {
   if (o.kick) ctl(o.kick.label, () => o.kick.onKick());
   const fullscreenBtn = ctl(t("ui.fullscreen"), () => void toggleFullscreen());
   fullscreenBtn.title = t("ui.fullscreen.hint");
-  const blastBtns = ["shelter", "fragmentHits", "confinement"].map((key) => ({ key, b: ctl(t(`ui.blast.${key}`), () => o.onBlast(key)) }));
-  for (const { key, b } of blastBtns) b.title = t(`ui.blast.${key}.hint`);
+  const blastBtns = ["shelter", "fragmentHits", "confinement"].map((key2) => ({ key: key2, b: ctl(t(`ui.blast.${key2}`), () => o.onBlast(key2)) }));
+  for (const { key: key2, b } of blastBtns) b.title = t(`ui.blast.${key2}.hint`);
   const qSel = mk3("select");
   for (const q of ["low", "medium", "high"]) {
     const op = mk3("option", void 0, t(`ui.quality.${q}`));
@@ -3943,6 +4527,7 @@ function createUi(o) {
   toggle.type = "button";
   const togglePanels = () => {
     root.classList.toggle("open");
+    if (isLogStale && isLogVisible()) rebuildLog();
     o.onResize();
   };
   toggle.onclick = togglePanels;
@@ -4031,6 +4616,7 @@ function createUi(o) {
       ring.style.display = value === null ? "none" : "block";
       if (value !== null) ringFill.style.strokeDashoffset = String(RING_LENGTH * (1 - value));
     },
+    flushLog,
     hud(s) {
       toolBox.textContent = "";
       toolBox.append(document.createTextNode(s.toolName));
@@ -4061,9 +4647,9 @@ function createUi(o) {
           held.append(mk3("kbd", void 0, k), document.createTextNode(` ${label}  `));
         }
       } else held.style.display = "none";
-      const key = s.slots.join("|") + s.page;
-      if (key !== lastSlotsKey) {
-        lastSlotsKey = key;
+      const key2 = s.slots.join("|") + s.page;
+      if (key2 !== lastSlotsKey) {
+        lastSlotsKey = key2;
         hotbar.textContent = "";
         slotsEl.length = 0;
         hudPage = s.page - 1;
@@ -4080,7 +4666,7 @@ function createUi(o) {
       slotsEl.forEach((b, i) => b.classList.toggle("on", i === s.slot));
       tapBtn.classList.toggle("on", s.tap);
       comboBtn?.classList.toggle("on", !!s.combo);
-      for (const { key: key2, b } of blastBtns) b.classList.toggle("on", s.blast[key2]);
+      for (const { key: key3, b } of blastBtns) b.classList.toggle("on", s.blast[key3]);
       count.textContent = t("ui.objects", { n: s.objects });
       const ak = JSON.stringify(s.animations);
       if (ak !== lastAnim) {
@@ -4131,7 +4717,7 @@ function createUi(o) {
 var FIXED_DT = 1 / 60;
 var SOLID_SPAN = 3;
 var STEP_UP = 0.45;
-var BODY_HEIGHT = 1.75;
+var BODY_HEIGHT2 = 1.75;
 var KICK_MASS = 6;
 var KICK_HEIGHT = 0.6;
 var GROUND_ID = "room_ground";
@@ -4143,9 +4729,8 @@ var GROUND_DUST_RADIUS = 0.2;
 var GROUND_FIRE_EVERY = 0.3;
 var SHOVE_SPEED = 0.04;
 var METRICS_INTERVAL_S = 0.25;
-var CARRY_NEAR = 0.62;
 var CARRY_PALM = 0.012;
-var CARRY_GRIP = 0.45;
+var CAP_RISE = 0.03;
 var MAX_STRIDE_SPEED = 10;
 var v3 = (v) => [v.x, v.y, v.z];
 var dist3 = (a, b) => Math.hypot(a[0] - b[0], a[1] - b[1], a[2] - b[2]);
@@ -4155,8 +4740,8 @@ function createTestRoom(options) {
   const S = resolveStrings(locale);
   const dStrings = resolveDestructionStrings(locale);
   const fStrings = resolveFluidStrings(locale);
-  const t = (key, vars) => {
-    let s = S.text[key] ?? key;
+  const t = (key2, vars) => {
+    let s = S.text[key2] ?? key2;
     if (vars) for (const k of Object.keys(vars)) s = s.split(`{${k}}`).join(String(vars[k]));
     return s;
   };
@@ -4241,11 +4826,11 @@ function createTestRoom(options) {
   const log = createLog({ exportCancelled: () => t("log.export_cancelled") });
   log.setClock(() => simTime);
   const ownAudio = options.audio === void 0;
-  const audio = options.audio === false ? null : options.audio ?? createAudioEngine();
+  const audio = options.audio === false ? null : options.audio ?? createAudioEngine({ deferredStart: {} });
   const destructionSound = audio ? createDestructionSound(audio) : null;
-  const playSound = (key, point, volume) => {
-    destructionSound?.onSound(key, point, volume);
-    options.onSound?.(key, point, volume);
+  const playSound = (key2, point, volume) => {
+    destructionSound?.onSound(key2, point, volume);
+    options.onSound?.(key2, point, volume);
   };
   const vfx = createVfxRenderer(THREE, {
     scene,
@@ -4255,6 +4840,7 @@ function createTestRoom(options) {
     pointScale,
     vfx: createVfx({
       profile: quality,
+      ...options.debris?.particles ? { sprites: { kinds: patchSpriteKinds(SPRITE_KINDS, options.debris.particles) } } : {},
       groundAt
     })
   });
@@ -4265,6 +4851,9 @@ function createTestRoom(options) {
     quality,
     groundAt,
     pointScale,
+    ...options.debris?.fragmentLife !== void 0 ? { fragmentLife: options.debris.fragmentLife } : {},
+    ...options.debris?.maxFragments !== void 0 ? { maxFragments: options.debris.maxFragments } : {},
+    eventBudgetMs: options.debris?.eventBudgetMs ?? 8,
     onSound: playSound,
     ...options.blastShove ? { blastShove: options.blastShove } : {},
     // a blast moves what is heavy but not nailed down: the renderer makes it a piece the moment the shove reaches it
@@ -4272,13 +4861,13 @@ function createTestRoom(options) {
       const e = entries.get(objectId);
       return e?.free === true && !e.piece;
     },
-    onLoosened: (objectId, piece) => {
+    onLoosened: (objectId, piece, cause) => {
       const e = entries.get(objectId);
       if (!e) return;
       e.piece = piece;
       leaveFootprint(objectId);
       rendererPieces.set(objectId, piece);
-      action("loosened", t("act.loosened", { name: e.name }), { objectId, itemId: e.so.itemId });
+      action("loosened", t(cause === "blast" ? "act.loosened" : "act.came_apart", { name: e.name }), { objectId, itemId: e.so.itemId });
     },
     onPiece: (piece) => {
       rendererPieces.set(piece.objectId, piece);
@@ -4494,7 +5083,7 @@ function createTestRoom(options) {
       const dz = Math.max(s.min[2] - z, 0, z - s.max[2]);
       if (dx * dx + dz * dz > radius * radius) continue;
       if (s.max[1] <= feet + STEP_UP) floor = Math.max(floor, s.max[1]);
-      else if (s.min[1] < feet + BODY_HEIGHT) blocked = true;
+      else if (s.min[1] < feet + BODY_HEIGHT2) blocked = true;
     }
     return { floor, blocked };
   };
@@ -4568,7 +5157,7 @@ function createTestRoom(options) {
     let best = null;
     let bestDistance = PUSH_REACH;
     for (const e of entries.values()) {
-      if (e.arena || !e.piece && !e.free) continue;
+      if (!e.pushable || !e.piece && !e.free) continue;
       const b = bodyBox(e);
       if (!b) continue;
       const dx = Math.max(b.minX, Math.min(b.maxX, player.x)) - player.x;
@@ -4592,7 +5181,7 @@ function createTestRoom(options) {
       aim();
       const r = rayWorld([aimO[0], aimO[1], aimO[2]], [aimD[0], aimD[1], aimD[2]], 3.2);
       const aimed = r ? rendererPieces.get(r.object)?.root ?? (entries.get(r.object)?.free ? entries.get(r.object)?.so.root : void 0) : void 0;
-      if (r && aimed) return { objectId: r.object, root: aimed, name: nameOf(r.object), piece: rendererPieces.get(r.object) ?? null };
+      if (r && aimed) return entries.get(r.object)?.pushable ? { objectId: r.object, root: aimed, name: nameOf(r.object), piece: rendererPieces.get(r.object) ?? null } : null;
       return leanedOn();
     },
     massOf: (objectId) => massOfObject(objectId),
@@ -4615,9 +5204,96 @@ function createTestRoom(options) {
       else if (ev.type === "too_heavy") say(t("hud.push_too_heavy", vars));
       else if (ev.type === "obstacle") say(t("hud.push_blocked", vars));
     },
-    ring: (value) => ui?.holdRing(value)
+    ring: (value) => ui?.holdRing(value),
+    hasBody: () => !!avatar?.eye
+  });
+  const seatHolder = (objectId) => {
+    const e = entries.get(objectId);
+    const seats = e?.item?.seats;
+    if (!e || !seats?.length || !world.has(objectId)) return null;
+    return { objectId, root: rendererPieces.get(objectId)?.root ?? e.so.root, seats };
+  };
+  const seating = createSeating({
+    THREE,
+    player,
+    pick: () => {
+      aim();
+      const r = rayWorld([aimO[0], aimO[1], aimO[2]], [aimD[0], aimD[1], aimD[2]], 3.2);
+      return r ? seatHolder(r.object) : null;
+    },
+    find: seatHolder,
+    hasBody: () => !!avatar?.eye,
+    groundAt: (x, z) => groundAt(x, z),
+    onSit: (seat) => action("sit", t(seat.pose === "lie" ? "act.lie" : "act.sit", { name: nameOf(seat.objectId) }), { objectId: seat.objectId, itemId: entryOf(seat.objectId)?.so.itemId, data: { seat: seat.seatId, pose: seat.pose } }),
+    onStand: (seat) => action("stand", t("act.stand", { name: nameOf(seat.objectId) }), { objectId: seat.objectId, itemId: entryOf(seat.objectId)?.so.itemId, data: { seat: seat.seatId } })
   });
   let pushByKey = false;
+  const leafCache = /* @__PURE__ */ new WeakMap();
+  const leavesOf = (objectId) => {
+    const item = entries.get(objectId)?.item;
+    if (!item?.animations?.length) return [];
+    const cached = leafCache.get(item);
+    if (cached) return cached;
+    const byPart = /* @__PURE__ */ new Map();
+    for (const clip of item.animations) {
+      if (!clip.id.startsWith("open_")) continue;
+      const parts = /* @__PURE__ */ new Set();
+      for (const k of clip.keys) for (const id of Object.keys(k.parts ?? {})) parts.add(id);
+      for (const part of parts) {
+        const had = byPart.get(part);
+        if (!had || parts.size < had.n) byPart.set(part, { clip, n: parts.size });
+      }
+    }
+    const leaves = [...byPart].map(([part, v]) => ({ part, clip: v.clip }));
+    leafCache.set(item, leaves);
+    return leaves;
+  };
+  const lockedLeaves = /* @__PURE__ */ new Set();
+  const doors = createRoomDoors({
+    THREE,
+    player,
+    world,
+    camera,
+    arena: { limit: arenaSize, colliders: standingColliders, ids: standingIds },
+    ...options.doors ? { rules: options.doors } : {},
+    pick: () => {
+      if (heldPiece) return [];
+      aim();
+      const hits = [];
+      const r = rayWorld([aimO[0], aimO[1], aimO[2]], [aimD[0], aimD[1], aimD[2]], DOOR_REACH);
+      if (r) hits.push({ objectId: r.object, part: r.part, point: r.point });
+      if (thirdActive()) {
+        camera.getWorldDirection(tmpV2);
+        const e = rayWorld([aimO[0], aimO[1], aimO[2]], [tmpV2.x, tmpV2.y, tmpV2.z], DOOR_REACH);
+        if (e) hits.push({ objectId: e.object, part: e.part, point: e.point });
+      }
+      return hits;
+    },
+    leaves: leavesOf,
+    objectOf: (objectId, part) => entries.get(objectId)?.so.root.getObjectByName(part) ?? null,
+    pose: (objectId, part, clip, fraction) => {
+      const e = entries.get(objectId);
+      const obj = e?.so.root.getObjectByName(part);
+      if (!e || !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] });
+      const rest = restPose.get(obj);
+      const pose = poseAt(clip, part, Math.max(0, Math.min(1, fraction)) * clip.duration);
+      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]);
+      followPart(e, part, obj, rest);
+    },
+    isLocked: (objectId, part) => lockedLeaves.has(`${objectId}\0*`) || lockedLeaves.has(`${objectId}\0${part}`),
+    nameOf,
+    impactKey: (objectId, part) => impactKey(world.materials.get(world.part(objectId, part)?.material ?? heaviestMaterial(objectId) ?? "")),
+    sound: playSound,
+    onEvent: (ev) => {
+      const vars = { name: ev.name, percent: Math.round(ev.opening * 100) };
+      action(`door_${ev.type}`, t(`act.door_${ev.type}`, vars), { objectId: ev.objectId, itemId: entryOf(ev.objectId)?.so.itemId, part: ev.part, data: { opening: Math.round(ev.opening * 1e3) / 1e3, ...ev.by ? { by: ev.by } : {} } });
+      fire("door", ev);
+      if (ev.type === "locked") say(t("hud.door_locked", vars));
+      else if (ev.type === "blocked") say(t("hud.door_blocked", vars));
+    }
+  });
   const massOfObject = (id) => {
     const st = world.state(id);
     let m = 0;
@@ -4643,6 +5319,8 @@ function createTestRoom(options) {
       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] });
+      e.fluidStart = f.container.liters;
+      e.fluidUsed = 0;
       fluidView.bindContainer(e.containerId, root, { innerOffset: e.fluidOffset });
     }
     return e;
@@ -4663,6 +5341,7 @@ function createTestRoom(options) {
       world.add(structuredCloneSpec(o.spec), { id: o.id, position: o.position, ...o.rotationY ? { rotation: [0, Math.sin(o.rotationY / 2), 0, Math.cos(o.rotationY / 2)] } : {} });
       const e = registerEntry(o.id, o.id, root, o.spec, o.label ?? S.text[`arena.${o.id}`] ?? o.id, void 0, void 0, true, false);
       if (o.free) e.free = true;
+      if (o.pushable) e.pushable = true;
       e.follower = o.follow?.(root, world, o.id) || null;
     }
   };
@@ -4762,7 +5441,7 @@ function createTestRoom(options) {
     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]];
+      if (!box2.isEmpty()) pos = [pos[0], pos[1] + (base - box2.min.y), pos[2]];
       root.position.set(pos[0], pos[1], pos[2]);
       root.updateMatrixWorld(true);
     }
@@ -4771,6 +5450,7 @@ function createTestRoom(options) {
     else world.add(spec, { id: objectId, position: pos, rotation: [q.x, q.y, q.z, q.w] });
     const e = registerEntry(objectId, item.id, root, spec, item.name, parts, item, false, movable);
     if (!own && !movable && item.movable === void 0) e.free = true;
+    if (item.pushable) e.pushable = true;
     action("spawn", t("act.spawn", { name: item.name, x: num(pos[0], 1), z: num(pos[2], 1) }), { objectId, itemId: item.id, data: { position: pos, movable, massKg: Math.round(massOfObject(objectId) * 10) / 10 } });
     fire("spawn", e.so);
     return e.so;
@@ -4873,6 +5553,7 @@ function createTestRoom(options) {
     e.so.root.removeFromParent();
     letGo(e.so.root);
     entries.delete(id);
+    doors.forget(id);
     rendererPieces.delete(id);
     specs.delete(id);
   };
@@ -4914,6 +5595,7 @@ function createTestRoom(options) {
     fluids.setTap(TAP_ID, false);
   };
   const clearListeners = /* @__PURE__ */ new Set();
+  const resetListeners = /* @__PURE__ */ new Set();
   const clear = () => {
     clearEverything();
     for (const listener of [...clearListeners]) listener();
@@ -4936,10 +5618,13 @@ function createTestRoom(options) {
     action("reset", t("act.reset"));
   };
   const hardReset = () => {
+    seating.release();
     pushByKey = false;
     push.end();
     clearEverything();
     for (const id of [...entries.keys()]) removeEntry(id);
+    renderer.reset();
+    for (const listener of [...resetListeners]) listener();
     tools.clear();
     tool = toolState(toolId);
     if (pristineWorld) {
@@ -4954,6 +5639,8 @@ function createTestRoom(options) {
     pending = [];
     strikes = [];
     rng = 12345;
+    filmRandom.seed = 1;
+    groundFireClock = 0;
     counter = 0;
     slot = 0;
     prevVy.clear();
@@ -4987,8 +5674,8 @@ function createTestRoom(options) {
   const thirdActive = () => cameraMode === "third" && avatar !== null;
   const syncAvatarVisible = () => {
     if (!avatar) return;
-    avatar.root.visible = cameraMode === "third";
-    if (avatar.firstPerson) avatar.firstPerson.root.visible = cameraMode === "first";
+    avatar.root.visible = cameraMode === "third" || !!avatar.eye;
+    avatar.setView?.(cameraMode, camera);
   };
   const setCameraMode = (mode) => {
     if (mode !== "first" && mode !== "third") return;
@@ -5001,13 +5688,13 @@ function createTestRoom(options) {
   };
   const setAvatar = (next) => {
     if (avatar === next) return;
+    avatar?.setView?.("third", null);
     avatar?.root.removeFromParent();
-    avatar?.firstPerson?.root.removeFromParent();
     avatar = next;
     feetPrev = null;
     if (avatar) {
+      avatar.root.userData.viewmodel = true;
       scene.add(avatar.root);
-      if (avatar.firstPerson) scene.add(avatar.firstPerson.root);
       syncAvatarVisible();
       stepAvatar(0);
     }
@@ -5029,34 +5716,73 @@ function createTestRoom(options) {
     avatarState.pitch = player.pitch;
     avatarState.holding = heldPiece !== null;
     avatarState.push = push.avatarState;
-    avatarState.itemUse = useItemPlayer ? { id: useItemName, ...useItemPlayer.pose() } : heldPiece && heldTilt > 0.01 ? { id: "tilt", position: [0.2, -0.1, -0.38], rotation: [-heldTilt, 0, 0] } : null;
+    const seat = seating.seat;
+    avatarState.seat = seat ? { pose: seat.pose, hip: seat.hips[1] - player.feet } : null;
+    avatarState.door = doors.avatarState;
+    avatarState.itemUse = useItemPlayer ? { id: useItemName, ...useItemPlayer.pose(), ...twistHand?.gripL !== void 0 ? { gripL: twistHand.gripL } : {} } : heldPiece && heldTilt > 0.01 ? { id: "tilt", position: [0.2, -0.1, -0.38], rotation: [-heldTilt, 0, 0] } : null;
     avatar.root.position.set(x, player.feet, z);
     avatar.root.rotation.set(0, player.yaw + Math.PI, 0);
     avatar.update(dt, avatarState);
     avatar.root.updateMatrixWorld(true);
+    placeEye();
+  };
+  let scriptedAt = null;
+  const lookAt = (eye, target) => {
+    player.look(eye, target);
+    scriptedAt = [player.x, player.z];
+  };
+  const EYE_CLEARANCE = 0.1;
+  const eyeAt = new THREE.Vector3();
+  const placeEye = () => {
+    if (!avatar?.eye) return;
+    if (scriptedAt) {
+      const [walkX, walkZ] = player.walkIntent;
+      if (!walkX && !walkZ && Math.hypot(player.x - scriptedAt[0], player.z - scriptedAt[1]) < 1e-6) return;
+      scriptedAt = null;
+    }
+    avatar.eye(eyeAt);
+    const dx = eyeAt.x - player.x;
+    const dz = eyeAt.z - player.z;
+    const ahead = Math.hypot(dx, dz);
+    if (ahead > 1e-4) {
+      const dir = [dx / ahead, 0, dz / ahead];
+      const hit = rayWorld([player.x, eyeAt.y, player.z], dir, ahead + EYE_CLEARANCE);
+      if (hit) {
+        const keep = Math.max(0, hit.distance - EYE_CLEARANCE);
+        eyeAt.set(player.x + dir[0] * keep, eyeAt.y, player.z + dir[2] * keep);
+      }
+    }
+    camera.position.copy(eyeAt);
+    camera.updateMatrixWorld(true);
   };
   let handSource = null;
-  let carriedHand = null;
   let debugView = null;
   let lastHand = { stance: "relaxed", triggerFinger: null, targets: null };
   const strikeClips = options.strikeClips ?? DEFAULT_STRIKE_CLIPS;
   const handStances = options.handStances ?? DEFAULT_HAND_STANCES;
-  const stepFirstPerson = (dt) => {
-    const arms = avatar?.firstPerson;
-    if (!arms) return;
-    const targets = push.handTargets() ?? handSource?.() ?? carriedHand;
-    const state = {
-      camera,
-      targets,
-      stance: push.active ? "hold" : handStances[toolId] ?? (targets ? "hold" : "relaxed"),
-      speed: avatarState.speed,
-      running: avatarState.running,
-      crouch: avatarState.crouch,
-      contact: (origin, direction, maxDistance) => rayWorld(origin, direction, maxDistance)?.distance ?? null,
-      triggerFinger: targets?.fingers?.index ?? null
+  const SHOULDER_POCKET_IN = 0.1;
+  const pocketAt = new THREE.Vector3();
+  const aimTurn = new THREE.Quaternion();
+  const aimEuler = new THREE.Euler(0, 0, 0, "YXZ");
+  const bodyHoldFrame = () => {
+    const shoulder = avatar?.shoulder?.("R");
+    if (!shoulder) return null;
+    shoulder.getWorldPosition(pocketAt);
+    pocketAt.x -= Math.cos(player.yaw) * SHOULDER_POCKET_IN;
+    pocketAt.z += Math.sin(player.yaw) * SHOULDER_POCKET_IN;
+    aimTurn.setFromEuler(aimEuler.set(player.pitch, player.yaw, 0, "YXZ"));
+    return { position: [pocketAt.x, pocketAt.y, pocketAt.z], quaternion: [aimTurn.x, aimTurn.y, aimTurn.z, aimTurn.w] };
+  };
+  const reachAvatar = () => {
+    const doorHand = doors.handTargets();
+    const targets = push.active ? null : heldPiece ? twistHand : handSource?.() ?? null;
+    lastHand = {
+      stance: push.active || doorHand ? "hold" : handStances[toolId] ?? (targets ? "hold" : "relaxed"),
+      triggerFinger: targets?.fingers?.index ?? null,
+      targets: push.handTargets() ?? doorHand ?? targets
     };
-    lastHand = { stance: state.stance, triggerFinger: state.triggerFinger, targets };
-    arms.update(dt, state);
+    if (!avatar?.reach) return;
+    avatar.reach(targets, { camera, keepOutside: { contact: (origin, direction, maxDistance) => rayWorld(origin, direction, maxDistance)?.distance ?? null } });
   };
   const applyThirdView = () => {
     if (!thirdActive()) return () => void 0;
@@ -5562,9 +6288,9 @@ function createTestRoom(options) {
   }
   let blastOptions = { ...options.blast };
   let lastBlast;
-  const blastOn = (key) => Boolean(blastOptions[key]);
-  const toggleBlast = (key) => {
-    blastOptions = { ...blastOptions, [key]: blastOn(key) ? false : true };
+  const blastOn = (key2) => Boolean(blastOptions[key2]);
+  const toggleBlast = (key2) => {
+    blastOptions = { ...blastOptions, [key2]: blastOn(key2) ? false : true };
   };
   const explosives = createExplosives({
     THREE,
@@ -5695,10 +6421,12 @@ function createTestRoom(options) {
   let tiltKey = 0;
   const heldLocal = new THREE.Vector3();
   const heldSize = new THREE.Vector3(0.2, 0.2, 0.2);
-  let heldRadius = 0.2;
   const heldVel = [0, 0, 0];
   let useItemPlayer = null;
   let useItemName = "";
+  let afterOpening = null;
+  let twisting = null;
+  let twistHand = null;
   const releaseHeld = () => {
     if (heldPiece) {
       heldPiece.held = false;
@@ -5707,6 +6435,9 @@ function createTestRoom(options) {
     }
     useItemPlayer?.cancel();
     useItemPlayer = null;
+    afterOpening = null;
+    twisting = null;
+    twistHand = null;
     heldEntry = null;
     heldPiece = null;
     heldTilt = 0;
@@ -5753,7 +6484,6 @@ function createTestRoom(options) {
     box2.getSize(heldSize);
     piece.root.quaternion.copy(savedQ);
     piece.root.updateMatrixWorld(true);
-    heldRadius = heldSize.length() / 3;
     heldYaw = 0;
     heldTilt = 0;
     heldVel[0] = heldVel[1] = heldVel[2] = 0;
@@ -5774,52 +6504,28 @@ function createTestRoom(options) {
     fire("throw", { objectId: id, speed });
     return true;
   };
-  const carriedTargets = (root, gripQ) => {
-    const width2 = Math.max(heldSize.x, heldSize.z);
-    const sideGrip = heldSize.y > width2 * 1.04 && width2 <= 0.22;
-    if (sideGrip) {
-      const center2 = heldLocal.clone().applyQuaternion(root.quaternion).add(root.position);
-      const radius = Math.min(heldSize.x, heldSize.z) * 0.5;
-      const handX = new THREE.Vector3(-0.35, 0, -0.94).normalize().applyQuaternion(gripQ);
-      const handY = new THREE.Vector3(0.94, 0, -0.35).normalize().applyQuaternion(gripQ);
-      const handZ = new THREE.Vector3().crossVectors(handX, handY).normalize();
-      const q2 = new THREE.Quaternion().setFromRotationMatrix(new THREE.Matrix4().makeBasis(handX, handY, handZ));
-      const up = new THREE.Vector3(0, 1, 0).applyQuaternion(gripQ);
-      const palm = center2.clone().addScaledVector(handY, radius + CARRY_PALM).addScaledVector(handX, -0.022).addScaledVector(up, heldSize.y > 0.16 ? -heldSize.y * 0.08 : -5e-3);
-      if (useItemName === "open" || useItemName === "close") {
-        const leftX = new THREE.Vector3(0.35, 0, -0.94).normalize().applyQuaternion(gripQ);
-        const leftY = new THREE.Vector3(-0.94, 0, -0.35).normalize().applyQuaternion(gripQ);
-        const leftZ = new THREE.Vector3().crossVectors(leftX, leftY).normalize();
-        const lq = new THREE.Quaternion().setFromRotationMatrix(new THREE.Matrix4().makeBasis(leftX, leftY, leftZ));
-        const leftPalm = center2.clone().addScaledVector(up, heldSize.y * 0.45).addScaledVector(leftY, radius * 0.65 + CARRY_PALM).addScaledVector(leftX, -0.018);
-        return {
-          R: { position: [palm.x, palm.y, palm.z], quaternion: [q2.x, q2.y, q2.z, q2.w] },
-          L: { position: [leftPalm.x, leftPalm.y, leftPalm.z], quaternion: [lq.x, lq.y, lq.z, lq.w] },
-          grip: 0.85,
-          gripL: 0.8
-        };
-      }
-      return { R: { position: [palm.x, palm.y, palm.z], quaternion: [q2.x, q2.y, q2.z, q2.w] }, grip: 0.85 };
-    }
-    const box2 = new THREE.Box3().setFromObject(root);
-    const center = box2.getCenter(new THREE.Vector3());
-    const forward = new THREE.Vector3(0, 0, -1).applyQuaternion(gripQ).normalize();
-    const back = new THREE.Vector3(0, -1, 0).applyQuaternion(gripQ).normalize();
-    const z = new THREE.Vector3().crossVectors(forward, back).normalize();
-    const y = new THREE.Vector3().crossVectors(z, forward).normalize();
-    const q = new THREE.Quaternion().setFromRotationMatrix(new THREE.Matrix4().makeBasis(forward, y, z));
-    return { R: { position: [center.x, box2.min.y - CARRY_PALM, center.z], quaternion: [q.x, q.y, q.z, q.w] }, grip: CARRY_GRIP };
+  const twistTargets = (root, gripQ) => {
+    if (!twisting) return null;
+    const { stroke, lift } = twisting;
+    const up = new THREE.Vector3(0, 1, 0).applyQuaternion(root.quaternion);
+    const top = heldLocal.clone().applyQuaternion(root.quaternion).add(root.position).addScaledVector(up, heldSize.y * 0.5 + lift * CAP_RISE + stroke.lift * TWIST_LIFT + CARRY_PALM);
+    const knuckles = new THREE.Vector3(0.85, 0, -0.5).normalize().applyQuaternion(gripQ);
+    knuckles.addScaledVector(up, -knuckles.dot(up)).normalize().applyAxisAngle(up, stroke.angle);
+    const side = new THREE.Vector3().crossVectors(knuckles, up).normalize();
+    const palm = top.addScaledVector(knuckles, -0.025);
+    const q = new THREE.Quaternion().setFromRotationMatrix(new THREE.Matrix4().makeBasis(knuckles, up, side));
+    return { L: { position: [palm.x, palm.y, palm.z], quaternion: [q.x, q.y, q.z, q.w] }, gripL: 0.35 + 0.5 * stroke.grip };
   };
   const gripQuat = new THREE.Quaternion();
   const followHeld = (dt) => {
     const piece = heldPiece;
-    carriedHand = null;
+    twistHand = null;
     if (!piece) return;
     camera.updateMatrixWorld(true);
     const root = piece.root;
     let pos;
     const targetQ = tmpQ;
-    const hand = thirdActive() ? avatar?.hand?.("R") : void 0;
+    const hand = avatar?.hand?.("R");
     const isDrink = useItemName === "drink" || useItemName === "sip" || useItemName === "chug";
     if (hand) {
       const handWorld = hand.getWorldPosition(tmpHand);
@@ -5835,7 +6541,7 @@ function createTestRoom(options) {
       pos = tmpV.copy(handWorld).add(gripOffset);
     } else if (useItemPlayer) {
       const pose = useItemPlayer.pose();
-      const frameQ = avatar?.firstPerson ? camera.quaternion : new THREE.Quaternion().setFromAxisAngle(new THREE.Vector3(0, 1, 0), player.yaw);
+      const frameQ = new THREE.Quaternion().setFromAxisAngle(new THREE.Vector3(0, 1, 0), player.yaw);
       const raise = isDrink ? Math.max(0, Math.min(1, (pose.position[1] + 0.2) / 0.22)) : 0;
       const px2 = pose.position[0] + (isDrink ? 0.02 * raise : 0);
       const py2 = pose.position[1] - (isDrink ? 0.08 * raise : 0);
@@ -5848,19 +6554,10 @@ function createTestRoom(options) {
       targetQ.copy(frameQ).multiply(eq);
       targetQ.multiply(new THREE.Quaternion().setFromAxisAngle(new THREE.Vector3(0, 1, 0), heldYaw));
     } else {
-      const small = heldRadius < 0.22;
-      const holdX = avatar?.firstPerson ? small ? 0.22 : 0.08 : 0.05;
-      const holdY = avatar?.firstPerson ? small ? -0.2 : -0.26 : -0.28;
-      const holdZ = avatar?.firstPerson ? small ? -0.42 : -Math.min(1.15, CARRY_NEAR + heldRadius) : -1.15;
-      pos = tmpV.set(holdX, holdY, holdZ).applyMatrix4(camera.matrixWorld);
-      const baseQ = avatar?.firstPerson && small ? camera.quaternion : new THREE.Quaternion().setFromAxisAngle(new THREE.Vector3(0, 1, 0), player.yaw);
-      gripQuat.copy(baseQ).multiply(new THREE.Quaternion().setFromAxisAngle(new THREE.Vector3(1, 0, 0), Math.max(-1.35, -heldTilt)));
+      pos = tmpV.set(0.05, -0.28, -1.15).applyMatrix4(camera.matrixWorld);
+      gripQuat.setFromAxisAngle(new THREE.Vector3(0, 1, 0), player.yaw).multiply(new THREE.Quaternion().setFromAxisAngle(new THREE.Vector3(1, 0, 0), Math.max(-1.35, -heldTilt)));
       targetQ.setFromAxisAngle(new THREE.Vector3(0, 1, 0), player.yaw + heldYaw);
-      if (avatar?.firstPerson && small && heldTilt <= 1e-4) {
-        targetQ.copy(camera.quaternion).multiply(new THREE.Quaternion().setFromAxisAngle(new THREE.Vector3(0, 1, 0), heldYaw));
-      } else {
-        targetQ.multiply(new THREE.Quaternion().setFromAxisAngle(new THREE.Vector3(1, 0, 0), -heldTilt));
-      }
+      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;
@@ -5875,8 +6572,50 @@ function createTestRoom(options) {
       heldVel[2] = (root.position.z - pz) / dt;
     }
     root.updateMatrixWorld(true);
-    if (avatar?.firstPerson && cameraMode === "first") carriedHand = carriedTargets(root, gripQuat);
+    twistHand = twistTargets(root, gripQuat);
+  };
+  const TOOL_REACH = 1.6;
+  const toolsAtHand = () => {
+    const here = player.position;
+    const near = [...loadout];
+    for (const other of entries.values()) {
+      if (other === heldEntry || other.arena) continue;
+      const p = other.so.root.position;
+      if (Math.hypot(p.x - here[0], p.z - here[2]) <= TOOL_REACH) near.push(other.so.itemId);
+    }
+    return near;
+  };
+  const sealLoss = (e) => {
+    if (e.sealLoss !== void 0) return e.sealLoss;
+    const c = e.containerId ? fluids.container(e.containerId) : void 0;
+    return c && e.fluidStart !== void 0 ? Math.max(0, e.fluidStart - c.liters - (e.fluidUsed ?? 0)) : 0;
+  };
+  const sealState = (e) => {
+    const breached = world.state(e.so.objectId)?.parts.some((p) => p.holes.some((h) => h.through && !h.vent)) ?? false;
+    const leaked = e.fluidStart !== void 0 && sealLoss(e) > Math.max(2e-3, e.fluidStart * 0.02);
+    return { opened: !!e.opened, breached, leaked };
+  };
+  const openSeal = (e) => {
+    const seal = e.item?.seal;
+    if (!seal || e.opened) return true;
+    const opener = sealOpener(seal, toolsAtHand());
+    if (!opener.ok) {
+      const listed = (seal.openWith ?? []).map((id) => catalogMap.get(id)?.name).filter((n) => !!n);
+      const names = [...new Set(listed.length ? listed : (seal.openWith ?? []).filter((id) => arsenal.weapons.has(id)).map((id) => toolName(id)))];
+      const why = t("hud.needs_opener", { name: e.name, tools: names.join(", ") });
+      say(why);
+      action("sealed", why, { objectId: e.so.objectId, itemId: e.so.itemId, data: { openWith: [...seal.openWith ?? []] } });
+      return false;
+    }
+    e.sealLoss = sealLoss(e);
+    e.opened = true;
+    if (e.containerId) fluids.open(e.containerId);
+    seal.open?.(wrapped.get(e.so.root) ?? e.so.root);
+    const tool2 = opener.tool ? catalogMap.get(opener.tool)?.name ?? (arsenal.weapons.has(opener.tool) ? toolName(opener.tool) : opener.tool) : void 0;
+    action("open_seal", tool2 ? t("act.open_with", { name: e.name, tool: tool2 }) : t("act.open_by_hand", { name: e.name }), { objectId: e.so.objectId, itemId: e.so.itemId, data: { tool: opener.tool ?? "hand" } });
+    return true;
   };
+  const crouchOnC = (options.crouch?.keys ?? ["KeyC"]).includes("KeyC");
   const useItem = (useId) => {
     const e = heldEntry;
     if (!e?.containerId) return false;
@@ -5885,25 +6624,90 @@ function createTestRoom(options) {
     const c = fluids.container(e.containerId);
     if (!c) return false;
     if (def.liquids && def.liquids.length > 0 && (!c.liquid || !def.liquids.includes(c.liquid))) return false;
-    const consuming = useId === "drink" || useId === "sip" || useId === "chug" || useId === "pour" || useId === "pour_out";
+    const eating = useId === "drink" || useId === "sip" || useId === "chug" || useId === "eat";
+    const consuming = eating || useId === "pour" || useId === "pour_out";
+    if (useItemPlayer && !useItemPlayer.done) return false;
+    const seal = e.item?.seal;
+    if (seal && (consuming || useId === "open")) {
+      const state = sealState(e);
+      const spoiled = sealBlock(seal, { ...state, opened: true });
+      if (eating && spoiled) {
+        say(t(spoiled === "leaked" ? "hud.spoiled_leak" : "hud.spoiled_hole", { name: e.name }));
+        action("spoiled", t(spoiled === "leaked" ? "hud.spoiled_leak" : "hud.spoiled_hole", { name: e.name }), { objectId: e.so.objectId, itemId: e.so.itemId, data: { reason: spoiled } });
+        return false;
+      }
+      if (!e.opened) {
+        const opening = seal.byHand && seal.openUse ? itemUseDefs.find((u) => u.id === seal.openUse) : void 0;
+        if (opening) {
+          useItemPlayer = createItemUse(fluids, e.containerId, opening);
+          useItemName = opening.id;
+          afterOpening = useId === "open" ? null : useId;
+          return true;
+        }
+        if (!openSeal(e)) return false;
+        if (!seal.byHand || useId === "open") {
+          useItemPlayer = createItemUse(fluids, e.containerId, itemUseDefs.find((u) => u.id === "open") ?? def);
+          useItemName = "open";
+          return true;
+        }
+      } else if (useId === "open") return false;
+    }
     if (consuming && c.liters <= 1e-6) {
       say(t("hud.empty_container", { name: e.name }));
       return false;
     }
-    if (useItemPlayer && !useItemPlayer.done) return false;
     if (consuming && c.closed) fluids.open(e.containerId);
     useItemPlayer = createItemUse(fluids, e.containerId, def);
     useItemName = def.id;
+    if (eating) useLiters = c.liters;
     action("use_item", t("act.use_item", { name: e.name, use: S.text[`use.${def.id}`] ?? def.id }), { objectId: e.so.objectId, itemId: e.so.itemId, data: { use: def.id } });
     return true;
   };
+  let useLiters = null;
   const updateItemUse = (dt) => {
     if (!useItemPlayer) return;
+    const e = heldEntry;
+    const c = e?.containerId ? fluids.container(e.containerId) : void 0;
+    const before = c?.liters;
     useItemPlayer.update(dt);
+    const seal = e?.item?.seal;
+    twisting = null;
+    if (e && seal?.openUse === useItemName && !e.opened) {
+      twisting = openingProgress(useItemPlayer.def, useItemPlayer.time);
+      seal.turn?.(wrapped.get(e.so.root) ?? e.so.root, { turned: twisting.stroke.turned, lift: twisting.lift });
+      if (twisting.lift >= 1 || useItemPlayer.done) {
+        openSeal(e);
+        twisting = null;
+      }
+    }
+    if (e && useLiters !== null && before !== void 0) {
+      const after = (e.containerId ? fluids.container(e.containerId)?.liters : void 0) ?? before;
+      e.fluidUsed = (e.fluidUsed ?? 0) + Math.max(0, before - after);
+      if (e.opened && e.fluidStart) e.item?.seal?.contents?.(wrapped.get(e.so.root) ?? e.so.root, after / e.fluidStart);
+    }
     if (useItemPlayer.done) {
+      if (e && useLiters !== null && useItemName === "eat") {
+        const left = (e.containerId ? fluids.container(e.containerId)?.liters : void 0) ?? 0;
+        action("ate", t(left <= 1e-4 ? "act.ate_all" : "act.ate", { name: e.name, grams: Math.round((useLiters - left) * 1e3) }), { objectId: e.so.objectId, itemId: e.so.itemId, data: { liters: Math.round((useLiters - left) * 1e3) / 1e3 } });
+      }
+      useLiters = null;
       useItemPlayer = null;
       useItemName = "";
-    }
+      const next = afterOpening;
+      afterOpening = null;
+      if (next && e?.opened) useItem(next);
+    }
+  };
+  const openingProgress = (def, time) => {
+    const keys = [...def.keys].sort((a, b) => a.t - b.t);
+    const turning = keys.findIndex((k) => k.action === "turn");
+    const lastTurn = keys.map((k) => k.action).lastIndexOf("turn");
+    const start = turning >= 0 ? keys[turning].t : 0;
+    const end = lastTurn >= 0 ? keys[lastTurn + 1]?.t ?? def.duration : start;
+    const openAt = keys.find((k) => k.action === "open")?.t ?? def.duration;
+    const share = end > start ? (time - start) / (end - start) : 1;
+    const lift = time <= end ? 0 : openAt > end ? Math.min(1, (time - end) / (openAt - end)) : 1;
+    return { stroke: twistStroke(share), lift };
   };
   const TAP_ID = "room_tap";
   const TAP_RATE = 0.25;
@@ -5982,7 +6786,7 @@ function createTestRoom(options) {
       if (code === "KeyZ") tiltKey = 0;
       if (code === "KeyE" && pushByKey) {
         pushByKey = false;
-        if (push.end()) grab();
+        if (push.end() && !doors.use()) grab();
       }
       return;
     }
@@ -6002,7 +6806,7 @@ function createTestRoom(options) {
       case "KeyE":
         if (e.repeat) break;
         pushByKey = !heldPiece && push.begin();
-        if (!pushByKey) grab();
+        if (!pushByKey && (heldPiece || !doors.use())) grab();
         break;
       case "KeyG":
         throwHeld();
@@ -6028,11 +6832,13 @@ function createTestRoom(options) {
       case "KeyZ":
         tiltKey = 1;
         break;
-      case "KeyF":
-        if (heldEntry?.uses[0]) useItem(heldEntry.uses[0]);
+      case "KeyF": {
+        const use = heldEntry?.uses[e.shiftKey && crouchOnC ? 1 : 0];
+        if (use) useItem(use);
         break;
+      }
       case "KeyC":
-        if (heldEntry?.uses[1] && !(options.crouch?.keys ?? ["KeyC"]).includes("KeyC")) useItem(heldEntry.uses[1]);
+        if (heldEntry?.uses[1] && !crouchOnC) useItem(heldEntry.uses[1]);
         break;
       case "KeyV":
         if (heldEntry?.uses[2]) useItem(heldEntry.uses[2]);
@@ -6077,6 +6883,12 @@ function createTestRoom(options) {
     aim();
     return rayWorld(aimO, aimD, 14);
   };
+  const leafNote = (distance) => {
+    if (distance > DOOR_REACH) return void 0;
+    const leaf = doors.aimed();
+    if (!leaf) return void 0;
+    return t(leaf.locked ? "hud.door_hint_locked" : leaf.open ? "hud.door_hint_close" : "hud.door_hint_open");
+  };
   const inspectInfo = () => {
     const r = inspectTarget();
     if (!r) return null;
@@ -6112,7 +6924,7 @@ function createTestRoom(options) {
       load: ext.load,
       stress: ext.stress,
       joints,
-      note: e?.item?.note,
+      note: leafNote(r.distance) ?? e?.item?.note,
       thumbnail: e?.item?.thumbnail,
       thumbnailCredit: e?.item?.thumbnailCredit,
       distance: r.distance
@@ -6176,6 +6988,7 @@ function createTestRoom(options) {
     }
     syncLiters();
     renderer.update(dt);
+    for (const e of entries.values()) e.follower?.update?.();
     terrainView.sync(camera.position);
     showGroundFire(dt);
     vfx.update(dt);
@@ -6203,12 +7016,14 @@ function createTestRoom(options) {
   const update = (dt) => {
     if (!ownsLoop) roomMetrics.frame(dt);
     frameStamp++;
+    seating.update();
     player.update(dt);
     if (pushByKey && !player.keys.has("KeyE")) {
       pushByKey = false;
       push.end();
     }
     push.step(paused ? 0 : dt);
+    doors.step(paused ? 0 : dt);
     if (!paused) kickLight(dt);
     if (!paused) pushByPlayer(dt);
     else player.takeWish();
@@ -6224,13 +7039,14 @@ function createTestRoom(options) {
     }
     if (!paused) followHeld(dt);
     stepSim(dt * timeScale);
-    stepFirstPerson(paused ? 0 : dt);
+    reachAvatar();
     if (progress && simTime - progress.at > 0.25) progress = null;
     hudAcc += dt;
     if (hudAcc >= 0.1 && ui) {
       hudAcc = 0;
       ui.hud(hudState());
     }
+    ui?.flushLog();
     metricsAcc += dt;
     if (metricsAcc >= METRICS_INTERVAL_S && ui) {
       metricsAcc = 0;
@@ -6251,7 +7067,7 @@ function createTestRoom(options) {
       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,
+      held: heldEntry || heldPiece ? { name: heldName, uses: (heldEntry?.uses ?? []).map((u, i) => ({ key: ["F", crouchOnC ? "Shift+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,
@@ -6292,17 +7108,33 @@ function createTestRoom(options) {
       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 ps = id === "" ? void 0 : specs.get(pl.entry.so.objectId)?.parts.find((p) => p.id === id);
-      if (ps) {
-        const r0 = ps.rotation ?? ZERO;
-        world.setPartPose(
-          pl.entry.so.objectId,
-          id,
-          [ps.position[0] + pose.position[0], ps.position[1] + pose.position[1], ps.position[2] + pose.position[2]],
-          [r0[0] + pose.rotation[0], r0[1] + pose.rotation[1], r0[2] + pose.rotation[2]]
-        );
-      }
-    }
+      if (id !== "") followPart(pl.entry, id, obj, rest);
+    }
+  };
+  const fpRest = new THREE.Matrix4();
+  const fpNow = new THREE.Matrix4();
+  const fpRoot = new THREE.Matrix4();
+  const fpPart = new THREE.Matrix4();
+  const fpPos = new THREE.Vector3();
+  const fpQuat = new THREE.Quaternion();
+  const fpScale = new THREE.Vector3();
+  const fpEuler = new THREE.Euler();
+  const followPart = (e, id, obj, rest) => {
+    const ps = specs.get(e.so.objectId)?.parts.find((p) => p.id === id);
+    if (!ps || !obj.parent) return;
+    const root = e.so.root;
+    root.updateMatrixWorld(true);
+    fpRoot.copy(root.matrixWorld).invert();
+    fpNow.multiplyMatrices(fpRoot, obj.matrixWorld);
+    fpEuler.set(rest.r[0], rest.r[1], rest.r[2]);
+    fpRest.compose(fpPos.set(rest.p[0], rest.p[1], rest.p[2]), fpQuat.setFromEuler(fpEuler), obj.scale);
+    fpRest.premultiply(obj.parent.matrixWorld).premultiply(fpRoot);
+    fpNow.multiply(fpRest.invert());
+    const r0 = ps.rotation ?? ZERO;
+    fpPart.compose(fpPos.set(ps.position[0], ps.position[1], ps.position[2]), fpQuat.setFromEuler(fpEuler.set(r0[0], r0[1], r0[2])), fpScale.set(1, 1, 1));
+    fpPart.premultiply(fpNow).decompose(fpPos, fpQuat, fpScale);
+    fpEuler.setFromQuaternion(fpQuat);
+    world.setPartPose(e.so.objectId, id, [fpPos.x, fpPos.y, fpPos.z], [fpEuler.x, fpEuler.y, fpEuler.z]);
   };
   const updateAnimations = (dt) => {
     for (let i = playing.length - 1; i >= 0; i--) {
@@ -6313,8 +7145,8 @@ function createTestRoom(options) {
       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") playSound(key, v3(pl.entry.so.root.getWorldPosition(tmpV)), 1);
+        const key2 = ev.type === "sound" ? ev.data?.key : void 0;
+        if (typeof key2 === "string") playSound(key2, v3(pl.entry.so.root.getWorldPosition(tmpV)), 1);
       }
       if (pl.t >= pl.clip.duration) {
         playing.splice(i, 1);
@@ -6336,10 +7168,10 @@ function createTestRoom(options) {
     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) => {
+    const grab2 = (key2, 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);
+      targets.set(key2, 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);
@@ -6366,9 +7198,9 @@ function createTestRoom(options) {
   const METRIC_UNAVAILABLE = "n/a";
   const metricText = (value, digits, unit) => typeof value === "number" ? `${num(value, digits)}${unit ? ` ${unit}` : ""}` : value ?? METRIC_UNAVAILABLE;
   const reportedFailures = /* @__PURE__ */ new Set();
-  const reportOnce = (key, text) => {
-    if (reportedFailures.has(key)) return;
-    reportedFailures.add(key);
+  const reportOnce = (key2, text) => {
+    if (reportedFailures.has(key2)) return;
+    reportedFailures.add(key2);
     host.log(text);
   };
   const failureText = (error) => error instanceof Error ? error.message : String(error);
@@ -6518,6 +7350,14 @@ function createTestRoom(options) {
       frameListeners.add(update2);
       return () => frameListeners.delete(update2);
     },
+    holdFrame: () => bodyHoldFrame(),
+    reachFor(reach) {
+      if (!avatar) {
+        reach.onGrip?.();
+        return;
+      }
+      doors.reachFor(reach);
+    },
     setHandTargets(source) {
       handSource = source;
       return () => {
@@ -6535,6 +7375,10 @@ function createTestRoom(options) {
       clearListeners.add(listener);
       return () => clearListeners.delete(listener);
     },
+    onReset(listener) {
+      resetListeners.add(listener);
+      return () => resetListeners.delete(listener);
+    },
     addObject(itemId, place) {
       return addScenery(itemId, place.position, place.rotationY);
     }
@@ -6562,13 +7406,32 @@ function createTestRoom(options) {
     return r.ok ? store : null;
   };
   const LIGHTS_CHECK_MS = 250;
+  const pinnedPrograms = /* @__PURE__ */ new WeakSet();
+  const pinPrograms = () => {
+    for (const program of gl.info?.programs ?? []) {
+      if (pinnedPrograms.has(program)) continue;
+      pinnedPrograms.add(program);
+      program.usedTimes++;
+    }
+  };
   const warmUp = () => {
     const probes = [renderer.warmUpProbes(), vfx.warmUpProbes(), fluidView.warmUpProbes()];
     const groups = probes.map((probe) => probe.group);
+    const spriteMap = new THREE.DataTexture(new Uint8Array([255, 255, 255, 255]), 1, 1);
+    spriteMap.needsUpdate = true;
+    const spriteProbes = [true, false].map((fog) => {
+      const probe = new THREE.Sprite(new THREE.SpriteMaterial({ map: spriteMap, transparent: true, fog }));
+      probe.frustumCulled = false;
+      return probe;
+    });
+    groups.push(...spriteProbes);
     scene.add(...groups);
     gl.render(scene, camera);
+    pinPrograms();
     scene.remove(...groups);
     for (const probe of probes) probe.dispose();
+    for (const probe of spriteProbes) probe.material.dispose();
+    spriteMap.dispose();
   };
   const warmUpEffects = () => {
     const ids = vfx.catalog?.() ?? [];
@@ -6599,11 +7462,14 @@ function createTestRoom(options) {
         build: (T) => ti.build(T),
         spec: ti.spec,
         movable: ti.movable,
+        pushable: ti.pushable,
         slow: ti.slow,
         fluid: ti.fluid,
+        seal: ti.seal,
         weapon: ti.weapon,
         impl: ti.impl,
         animations: ti.animations,
+        seats: ti.seats,
         thumbnail: ti.thumbnail,
         thumbnailCredit: ti.thumbnailCredit
       };
@@ -6660,15 +7526,20 @@ function createTestRoom(options) {
     const kept = previous?.encode();
     previous?.dispose();
     benches.delete(mod.id);
-    for (const key of [...reportedFailures]) if (key.startsWith(`${mod.id}:`)) reportedFailures.delete(key);
+    for (const key2 of [...reportedFailures]) if (key2.startsWith(`${mod.id}:`)) reportedFailures.delete(key2);
     modules.set(mod.id, mod);
     if (bench) {
       const seed = options.bench?.state?.[mod.id];
       const restored = kept ?? (typeof seed === "string" ? seed : void 0);
       if (restored !== void 0) bench.restore(restored);
       benches.set(mod.id, bench);
+      let reportedState = bench.encode();
       bench.watch(() => {
-        options.bench?.onChange?.(mod.id, bench.encode());
+        const encoded = bench.encode();
+        if (encoded !== reportedState) {
+          reportedState = encoded;
+          options.bench?.onChange?.(mod.id, encoded);
+        }
         if (activeBench === mod.id) ui?.bench(benchView());
       });
       if (!activeBench || !benches.has(activeBench)) activeBench = mod.id;
@@ -6690,8 +7561,10 @@ function createTestRoom(options) {
     const dt = seconds > 6 ? 1 / 30 : FIXED_DT;
     const n = Math.max(1, Math.round(seconds / dt));
     for (let i = 0; i < n; i++) {
+      seating.update();
       player.update(0);
       push.step(dt);
+      doors.step(dt);
       followHeld(dt);
       stepSim(dt);
     }
@@ -6826,7 +7699,7 @@ function createTestRoom(options) {
         room.waitUntilReady();
         return true;
       },
-      look: (eye, target) => player.look(eye, target),
+      look: (eye, target) => lookAt(eye, target),
       use: (hold) => room.use(hold),
       blastAt: (weapon, point) => {
         const def = arsenal.weapons.get(weapon);
@@ -6882,7 +7755,7 @@ function createTestRoom(options) {
     grab,
     throwHeld,
     look(position, target) {
-      player.look(position, target);
+      lookAt(position, target);
     },
     inspect() {
       const r = inspectTarget();
@@ -6949,11 +7822,23 @@ function createTestRoom(options) {
     busy: (label, work, busyOptions) => loading.busy(label, work, busyOptions),
     loadModule,
     warmUp: () => {
+      audio?.warmUp();
       warmUp();
       warmUpEffects();
     },
     animations: animationsOf,
     playAnimation,
+    useLeaf: (objectId, part) => doors.useLeaf(objectId, part),
+    leafOpening: (objectId, part) => doors.opening(objectId, part ?? leavesOf(objectId)[0]?.part ?? ""),
+    leaves: (objectId) => leavesOf(objectId).map((l) => l.part),
+    lockLeaf(objectId, locked = true, part) {
+      const k = `${objectId}\0${part ?? "*"}`;
+      if (locked) lockedLeaves.add(k);
+      else lockedLeaves.delete(k);
+    },
+    get door() {
+      return doors.state;
+    },
     bench(moduleId) {
       const id = moduleId ?? activeBench;
       return (id ? benches.get(id) : void 0) ?? null;
@@ -6996,6 +7881,11 @@ function createTestRoom(options) {
     get playerPosition() {
       return player.position;
     },
+    sit: (objectId, seatId) => seating.sit(objectId, seatId),
+    stand: () => seating.stand(),
+    get seat() {
+      return seating.seat;
+    },
     push: { begin: () => push.begin(), end: () => push.end(), setWalk: (walk) => push.setWalk(walk), get state() {
       return push.state;
     } },
@@ -7098,8 +7988,8 @@ function createTestRoom(options) {
       },
       onTap: () => toggleTap(),
       ...combo ? { combo: { label: combo.name?.[locale] ?? combo.id, onToggle: () => setStrikeCombo(!comboOn) } } : {},
-      ...arsenal.weapons.has("kick") ? { kick: { label: `${t("ui.kick")} (${kickKeys.map((key) => key.replace(/^Key/, "")).join("/")})`, onKick: () => void kick() } } : {},
-      onBlast: (key) => toggleBlast(key),
+      ...arsenal.weapons.has("kick") ? { kick: { label: `${t("ui.kick")} (${kickKeys.map((key2) => key2.replace(/^Key/, "")).join("/")})`, onKick: () => void kick() } } : {},
+      onBlast: (key2) => toggleBlast(key2),
       onPlay: (objectId, clipId) => {
         playAnimation(clipId, objectId);
       },
@@ -7125,19 +8015,19 @@ function createTestRoom(options) {
     let nextLightsCheck = 0;
     let warmedLights = "";
     const lightsKey = () => {
-      let key = "";
+      let key2 = "";
       scene.traverseVisible((object) => {
-        if (object.isLight) key += `${object.type[0]}${object.castShadow ? "s" : ""}`;
+        if (object.isLight) key2 += `${object.type[0]}${object.castShadow ? "s" : ""}`;
       });
-      return key;
+      return key2;
     };
     const loop = (now) => {
       raf = requestAnimationFrame(loop);
       if (now >= nextLightsCheck) {
         nextLightsCheck = now + LIGHTS_CHECK_MS;
-        const key = lightsKey();
-        if (key !== warmedLights) {
-          warmedLights = key;
+        const key2 = lightsKey();
+        if (key2 !== warmedLights) {
+          warmedLights = key2;
           warmUp();
         }
       }
@@ -7148,6 +8038,7 @@ function createTestRoom(options) {
       if (!scenarioRunning) update(dt);
       const restoreCamera = room.applyCamera();
       gl.render(scene, debugView ?? camera);
+      pinPrograms();
       restoreCamera();
       roomMetrics.rendered();
     };