npm - @adatechnology/game-weapons-three - Versions diffs - 0.11.1 → 0.11.3 - Mend

@adatechnology/game-weapons-three 0.11.1 → 0.11.3

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (5) hide show

package/dist/index.global.js CHANGED Viewed

@@ -16241,6 +16241,94 @@ ${problems.map((problem) => `  - ${problem}`).join("\n")}`);
       return mesh3;
     });
   }
+  var isTexture = (v) => !!v && typeof v === "object" && v.isTexture === true;
+  function texturesOf(material, out) {
+    for (const value of Object.values(material)) if (isTexture(value)) out.add(value);
+    const uniforms = material.uniforms;
+    if (uniforms) {
+      for (const u of Object.values(uniforms)) if (isTexture(u?.value)) out.add(u.value);
+    }
+  }
+  function collect(roots) {
+    const geometries = /* @__PURE__ */ new Set();
+    const materials = /* @__PURE__ */ new Set();
+    const textures = /* @__PURE__ */ new Set();
+    const skeletons = /* @__PURE__ */ new Set();
+    for (const root of roots) {
+      root.traverse((object2) => {
+        const o = object2;
+        if (o.geometry && typeof o.geometry.dispose === "function") geometries.add(o.geometry);
+        if (o.skeleton && typeof o.skeleton.dispose === "function") skeletons.add(o.skeleton);
+        const list2 = Array.isArray(o.material) ? o.material : o.material ? [o.material] : [];
+        for (const m of list2) {
+          if (!m || typeof m.dispose !== "function") continue;
+          materials.add(m);
+          texturesOf(m, textures);
+        }
+      });
+    }
+    return { geometries, materials, textures, skeletons };
+  }
+  var marked = /* @__PURE__ */ new WeakSet();
+  function markShared(...resources) {
+    for (const resource of resources) marked.add(resource);
+    return resources;
+  }
+  var shared = (r) => r.userData?.shared === true || marked.has(r);
+  function releaseObject3D(roots, options = {}) {
+    const list2 = Array.isArray(roots) ? roots : [roots];
+    const report = { geometries: 0, materials: 0, textures: 0 };
+    if (list2.length === 0) return report;
+    const found = collect(list2);
+    const keepRoots = options.keep === void 0 ? [] : Array.isArray(options.keep) ? options.keep : [options.keep];
+    const releasing = new Set(list2);
+    for (const keep of keepRoots) {
+      const walk = (o) => {
+        if (releasing.has(o)) return;
+        const owner = o;
+        if (owner.geometry) found.geometries.delete(owner.geometry);
+        if (owner.skeleton) found.skeletons.delete(owner.skeleton);
+        const mats = Array.isArray(owner.material) ? owner.material : owner.material ? [owner.material] : [];
+        for (const m of mats) {
+          if (!m) continue;
+          found.materials.delete(m);
+          const t = /* @__PURE__ */ new Set();
+          texturesOf(m, t);
+          for (const x of t) found.textures.delete(x);
+        }
+        for (const c of o.children) walk(c);
+      };
+      walk(keep);
+    }
+    for (const g of found.geometries) {
+      if (shared(g)) continue;
+      g.dispose();
+      report.geometries++;
+    }
+    for (const m of found.materials) {
+      if (shared(m)) continue;
+      m.dispose();
+      report.materials++;
+    }
+    for (const t of found.textures) {
+      if (shared(t)) continue;
+      t.dispose();
+      report.textures++;
+    }
+    for (const s of found.skeletons) s.dispose();
+    return report;
+  }
+  function discardObject3D(objects, options = {}) {
+    const list2 = Array.isArray(objects) ? objects : [objects];
+    const keep = options.keep === void 0 ? [] : Array.isArray(options.keep) ? [...options.keep] : [options.keep];
+    for (const object2 of list2) {
+      let top = object2;
+      while (top.parent) top = top.parent;
+      object2.removeFromParent();
+      if (top !== object2 && !keep.includes(top)) keep.push(top);
+    }
+    return releaseObject3D(list2, { keep });
+  }
   // ../game-props3d/dist/index.js
   function rng(seed) {
@@ -19439,9 +19527,9 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     const tz = 2 * (qx * v[1] - qy * v[0]);
     return [v[0] + qw * tx + (qy * tz - qz * ty), v[1] + qw * ty + (qz * tx - qx * tz), v[2] + qw * tz + (qx * ty - qy * tx)];
   };
-  var toLocal = (position, rotation, p) => rotateVec([-rotation[0], -rotation[1], -rotation[2], rotation[3]], [p[0] - position[0], p[1] - position[1], p[2] - position[2]]);
-  var toWorld = (position, rotation, p) => {
-    const r = rotateVec(rotation, p);
+  var toLocal = (position, rotation2, p) => rotateVec([-rotation2[0], -rotation2[1], -rotation2[2], rotation2[3]], [p[0] - position[0], p[1] - position[1], p[2] - position[2]]);
+  var toWorld = (position, rotation2, p) => {
+    const r = rotateVec(rotation2, p);
     return [r[0] + position[0], r[1] + position[1], r[2] + position[2]];
   };
   var shapeDims = (s) => {
@@ -19846,8 +19934,8 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
   };
   var cellsOutside = (cells, thin, point, radius) => cells.filter((c) => planeDistance(c, thin, point) > radius);
   var MAX_MARKS_PER_FRAGMENT = 12;
-  var marksInBox = (center, size, rotation, holes) => {
-    const inverse = rotation ? quat.conjugate(rotation) : void 0;
+  var marksInBox = (center, size, rotation2, holes) => {
+    const inverse = rotation2 ? quat.conjugate(rotation2) : void 0;
     const marks = [];
     for (const hole of holes) {
       const offset = [hole.point[0] - center[0], hole.point[1] - center[1], hole.point[2] - center[2]];
@@ -21989,6 +22077,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
   var CHIP_ENERGY = 200;
   var CHIP_SPLASH = 0.5;
   var CRATER_SPENT = 0.6;
+  var EDGE_REACH = 1.5;
   var BAR_BOW = 0.08;
   var BULLET_JOINT_SPAN = 0.3;
   var CUT_SLICE = 1;
@@ -22440,8 +22529,8 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       }
       solveStructure(o);
       if (peak <= sec.steel) return;
-      const rotation = (elasticEnergy(peak, L, EI, flexure.loadFactor) - elasticEnergy(sec.steel, L, EI, flexure.loadFactor)) / (2 * sec.steel);
-      p.rt.hinge = (p.rt.hinge ?? 0) + rotation;
+      const rotation2 = (elasticEnergy(peak, L, EI, flexure.loadFactor) - elasticEnergy(sec.steel, L, EI, flexure.loadFactor)) / (2 * sec.steel);
+      p.rt.hinge = (p.rt.hinge ?? 0) + rotation2;
       markDamaged(p);
       if (p.rt.hinge >= flexure.failRotationDeg * Math.PI / 180) hingeDrop(o, p, src);
     };
@@ -23143,8 +23232,8 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     const detachEvents = (o, opened, by, src) => {
       for (const j of opened) emit2({ ...base(o, src), type: "detach", joint: j.spec.id, parts: [j.spec.a, j.spec.b], by, groups: o.st.groups.map((g) => [...g]) });
     };
-    const slideOffResting = (o, rotation) => {
-      const upY = 1 - 2 * (rotation[0] * rotation[0] + rotation[2] * rotation[2]);
+    const slideOffResting = (o, rotation2) => {
+      const upY = 1 - 2 * (rotation2[0] * rotation2[0] + rotation2[2] * rotation2[2]);
       if (upY >= RESTING_HOLD_COS) return;
       const opened = o.joints.filter((j) => j.spec.kind === "resting" && !j.st.open);
       if (opened.length === 0) return;
@@ -23362,6 +23451,9 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
           const lo = cell.center[a] - cell.size[a] / 2 + w / 2, hi = cell.center[a] + cell.size[a] / 2 - w / 2;
           size[a] = w;
           center[a] = clamp2(lp[a], lo, hi);
+          const [from, to] = tornToEdge({ p, cell, a, b: a === u ? v : u, at: lp[a], crater: [center[a] - w / 2, center[a] + w / 2], reach: w * EDGE_REACH, gone: (k) => worn[k] === -1 });
+          size[a] = to - from;
+          center[a] = (from + to) / 2;
         }
         const taken2 = (cut[i] ?? 0) + size[u] * size[v];
         if (taken2 >= cell.size[u] * cell.size[v] * CRATER_SPENT) {
@@ -23399,6 +23491,19 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         collapseCheck(o, src);
       }
     };
+    const tornToEdge = (o) => {
+      const { p, cell, a, b, at: at3, crater: crater2, reach, gone } = o;
+      const half = p.dims[a] / 2;
+      const lo = cell.center[a] - cell.size[a] / 2, hi = cell.center[a] + cell.size[a] / 2;
+      const free = (side, sign2) => {
+        if (sign2 > 0 ? side >= half - 1e-6 : side <= -half + 1e-6) return sign2 > 0 || a !== planeAxes(p.thin)[1];
+        const probe = side + sign2 * 1e-3;
+        return gridOf(p).some((c, k) => gone(k) && Math.abs(probe - c.center[a]) <= c.size[a] / 2 && Math.abs(cell.center[b] - c.center[b]) <= c.size[b] / 2);
+      };
+      if (at3 - lo <= reach && free(lo, -1)) return [lo, Math.max(crater2[1], lo)];
+      if (hi - at3 <= reach && free(hi, 1)) return [Math.min(crater2[0], hi), hi];
+      return crater2;
+    };
     const craterAcross = (energy) => clamp2(0.03 + 12e-4 * Math.sqrt(Math.max(0, energy)), 0.03, 0.14);
     const craterFragments = (o, p, cell, dir, speed, mass, tag) => {
       const { c, q } = partXf(o, p);
@@ -24551,11 +24656,11 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         impls.set(id, { impl, position: opts.position ?? [0, 0, 0], rotation: opts.rotation ?? [0, 0, 0, 1], poses: /* @__PURE__ */ new Map() });
         return id;
       },
-      setPartPose(objectId, partId, position, rotation) {
-        const q = quatFromEuler(...rotation ?? [0, 0, 0]);
+      setPartPose(objectId, partId, position, rotation2) {
+        const q = quatFromEuler(...rotation2 ?? [0, 0, 0]);
         const im = impls.get(objectId);
         if (im) {
-          im.impl.setPartPose?.(partId, position, rotation);
+          im.impl.setPartPose?.(partId, position, rotation2);
           im.poses.set(partId, { pos: [position[0], position[1], position[2]], q });
           return;
         }
@@ -24572,17 +24677,17 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       },
       has: (id) => taken(id),
       ids: () => [...objects.keys(), ...impls.keys()],
-      setTransform(id, position, rotation) {
+      setTransform(id, position, rotation2) {
         const im = impls.get(id);
         if (im) {
           im.position = [position[0], position[1], position[2]];
-          im.rotation = [rotation[0], rotation[1], rotation[2], rotation[3]];
+          im.rotation = [rotation2[0], rotation2[1], rotation2[2], rotation2[3]];
           return;
         }
         const o = getObj(id);
-        o.base = { pos: [position[0], position[1], position[2]], rot: [rotation[0], rotation[1], rotation[2], rotation[3]] };
+        o.base = { pos: [position[0], position[1], position[2]], rot: [rotation2[0], rotation2[1], rotation2[2], rotation2[3]] };
         applySoilPose(o);
-        slideOffResting(o, rotation);
+        slideOffResting(o, rotation2);
       },
       splitGroup(id, group, newId) {
         if (impls.has(id)) throw new Error(`object "${id}" is a registered DestructibleImpl and cannot be split; its module owns its pieces`);
@@ -28092,9 +28197,9 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
   var SHARED_ROOMS = { west: { type: "laundry", label: "laundry_room" }, east: { type: "storage", label: "storage_room" } };
   var apartments = (plan) => (strip, { floor: floor2, plate, ceiling }) => {
     if (strip.length < plan.apartmentMin) {
-      const shared = SHARED_ROOMS[strip.id] ?? SHARED_ROOMS.east;
-      const id = `${shared.label}_${floor2}_${strip.id}`;
-      return { rooms: [{ id, type: shared.type, label: shared.label, rect: [...strip.rect] }], doors: [stripDoor(id, strip, floor2, 0.9)], windows: exteriorWindows(id, strip.rect, plate, ceiling, { ...plan.window, width: 1.2 }) };
+      const shared2 = SHARED_ROOMS[strip.id] ?? SHARED_ROOMS.east;
+      const id = `${shared2.label}_${floor2}_${strip.id}`;
+      return { rooms: [{ id, type: shared2.type, label: shared2.label, rect: [...strip.rect] }], doors: [stripDoor(id, strip, floor2, 0.9)], windows: exteriorWindows(id, strip.rect, plate, ceiling, { ...plan.window, width: 1.2 }) };
     }
     const count = Math.max(1, Math.round(strip.length / plan.apartment)), wide2 = strip.length / count;
     const parts = Array.from({ length: count }, (_, k) => apartment(strip, floor2, k, r22(k * wide2), r22((k + 1) * wide2), plate, ceiling, plan.window));
@@ -28208,7 +28313,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
   var OPEN_ROOM_TYPES2 = /* @__PURE__ */ new Set(["balcony", "terrace", "veranda", "balcony_gourmet"]);
   var rectsOf = (c) => c.parts && c.parts.length ? c.parts : [[c.u0, c.v0, c.u1, c.v1]];
   var isOpenArea = (c) => OPEN_ROOM_TYPES2.has(c.type) || c.outdoor === true;
-  function installKernelGeometry(K, shared) {
+  function installKernelGeometry(K, shared2) {
     const { THREE } = K;
     const GEO = {};
     {
@@ -28267,9 +28372,9 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     const cursor = { group: "lot", accs: /* @__PURE__ */ new Map(), rot: [], org: [0, 0, 0], ry: 0 };
     const PARTS = [];
     const MIRRORS = [];
-    shared.partCount = 0;
+    shared2.partCount = 0;
     function part(type, pos, fn, meta = {}, parent, ry = 0) {
-      const gA = cursor.group, oA = cursor.org, rA = cursor.ry, pieceA = cursor.pc, name = "part:" + (meta.id || type) + ":" + shared.partCount++;
+      const gA = cursor.group, oA = cursor.org, rA = cursor.ry, pieceA = cursor.pc, name = "part:" + (meta.id || type) + ":" + shared2.partCount++;
       PARTS.push({ name, parent: parent || gA, pos: pos.slice(), type, meta, ry });
       cursor.group = name;
       cursor.org = pos;
@@ -28304,7 +28409,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     }
     const _Y = new THREE.Vector3(0, 1, 0), _qa = new THREE.Quaternion(), _qb = new THREE.Quaternion();
     function pieceRecord(id, mat, role, extra) {
-      const M = shared.ctx.pieces;
+      const M = shared2.ctx.pieces;
       let p = M.get(id);
       if (!p) {
         p = Object.assign({ id, mat, role: role || null }, extra);
@@ -28313,7 +28418,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       return p;
     }
     const structurePiece = (id) => {
-      const e = shared.ctx.structureIndex && shared.ctx.structureIndex[id];
+      const e = shared2.ctx.structureIndex && shared2.ctx.structureIndex[id];
       return e ? pieceRecord(id, e.material, e.role, { floor: e.floor }) : null;
     };
     function accFor(mat) {
@@ -28762,7 +28867,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     const NO_SHADOW = /* @__PURE__ */ new Set(["dirt", "glass", "water", "screen", "building", "picture", "floor", "emissive"]);
     Object.assign(K, { createMaterials: createMaterials2, antiTile, dirtMaterial, CLOTHES_UNIFORMS, clothesMaterial, ORDER: ORDER2, NO_SHADOW });
   }
-  function installKernelCloseScene(K, shared) {
+  function installKernelCloseScene(K, shared2) {
     const { THREE, NO_SHADOW, ORDER: ORDER2, PARTS, applyPart, cursor } = K;
     const assembleCars = (...a) => K.assembleCars(...a);
     const assembleMirrors = (...a) => K.assembleMirrors(...a);
@@ -28777,7 +28882,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       if (!fx.length) return;
       const u = m.userData, ids = [...new Set(fx.map((f) => f.id))], weight = {};
       for (const f of fx) {
-        const mt = shared.ctx.pieces.get(f.id).mat;
+        const mt = shared2.ctx.pieces.get(f.id).mat;
         weight[mt] = (weight[mt] || 0) + f.v1 - f.v0;
       }
       u.ranges = fx;
@@ -28785,7 +28890,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       u.destructionMaterial = Object.keys(weight).sort((a, b) => weight[b] - weight[a])[0];
       if (ids.length === 1) {
         u.destructionPart = ids[0];
-        const pc = shared.ctx.pieces.get(ids[0]);
+        const pc = shared2.ctx.pieces.get(ids[0]);
         if (pc.role) u.structuralRole = pc.role;
       }
     }
@@ -28828,7 +28933,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
           if (P.meta.t0) applyPart(g, P.meta.t0);
         }
         (groups[P.parent] || (groups[P.parent] = new THREE.Group())).add(g);
-        if (P.meta.id) (shared.ctx.parts || (shared.ctx.parts = {}))[P.meta.id] = g;
+        if (P.meta.id) (shared2.ctx.parts || (shared2.ctx.parts = {}))[P.meta.id] = g;
       }
       PARTS.length = 0;
       assembleMirrors(groups);
@@ -28838,20 +28943,20 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     }
     Object.assign(K, { markMesh, closeScene });
   }
-  function installHouseHelpers(K, shared) {
-    shared.ctx = {};
+  function installHouseHelpers(K, shared2) {
+    shared2.ctx = {};
     const OPEN_ROOM_TYPES22 = /* @__PURE__ */ new Set(["balcony", "terrace", "veranda", "balcony_gourmet"]);
     const NO_CEILING = OPEN_ROOM_TYPES22;
     const OPEN_AREA = (c) => OPEN_ROOM_TYPES22.has(c.type) || c.outdoor === true;
     const EPS6 = 1e-3;
     const Y0 = (f) => {
-      const A = shared.ctx.r.floors;
+      const A = shared2.ctx.r.floors;
       return A[Math.max(0, Math.min(A.length - 1, f))].y0;
     };
-    const colorOf = (v) => typeof v === "number" ? v : typeof v === "string" && shared.ctx.colors[v] != null ? shared.ctx.colors[v] : null;
+    const colorOf = (v) => typeof v === "number" ? v : typeof v === "string" && shared2.ctx.colors[v] != null ? shared2.ctx.colors[v] : null;
     const rectsOf2 = (c) => c.parts && c.parts.length ? c.parts : [[c.u0, c.v0, c.u1, c.v1]];
     function roomAt(f, u, v) {
-      for (const c of shared.ctx.r.rooms) if (c.floor === f) {
+      for (const c of shared2.ctx.r.rooms) if (c.floor === f) {
         for (const [a, b, c2, d] of rectsOf2(c)) if (u > a + EPS6 && u < c2 - EPS6 && v > b + EPS6 && v < d - EPS6) return c;
       }
       return null;
@@ -28879,14 +28984,14 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       return [Math.min(...pts.map((p) => p[0])), Math.min(...pts.map((p) => p[1])), Math.max(...pts.map((p) => p[0])), Math.max(...pts.map((p) => p[1]))];
     }
     function effectiveHeight(f, h) {
-      const A = shared.ctx.r.floors;
+      const A = shared2.ctx.r.floors;
       if (f + 1 >= A.length) return h;
       const pitch = A[f + 1].y0 - A[f].y0;
       return h > pitch && h - pitch <= 0.45 ? pitch : h;
     }
     Object.assign(K, { OPEN_ROOM_TYPES: OPEN_ROOM_TYPES22, NO_CEILING, OPEN_AREA, EPS: EPS6, Y0, colorOf, rectsOf: rectsOf2, roomAt, subRect, subRects, wallColor, floorColor, stairFootprint, effectiveHeight });
   }
-  function installHouseWalls(K, shared) {
+  function installHouseWalls(K, shared2) {
     const { EPS: EPS6, Y0, boxC, bx, cursor, effectiveHeight, pieceRecord, structurePiece, wallColor } = K;
     function wallBox(alongU, L, a, b, ya, yb, th, cL, cH, mL, mH) {
       if (yb - ya < 1e-4 || b - a < 1e-4) return;
@@ -28899,10 +29004,10 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       }
     }
     function sideOf(id, frontLine) {
-      const R = shared.ctx.r, F = R.facade;
-      if (id === "outside" || !shared.ctx.roomById[id]) {
+      const R = shared2.ctx.r, F = R.facade;
+      if (id === "outside" || !shared2.ctx.roomById[id]) {
         const ac = F.finish;
-        let mat = "plaster", color2 = shared.ctx.colors.facade;
+        let mat = "plaster", color2 = shared2.ctx.colors.facade;
         if (ac === "roughcast") mat = "roughcast";
         else if (ac === "exposed_block") {
           mat = "block";
@@ -28913,12 +29018,12 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         }
         return { color: color2, mat, exterior: true };
       }
-      return { color: wallColor(shared.ctx.roomById[id]), mat: "plaster", exterior: false };
+      return { color: wallColor(shared2.ctx.roomById[id]), mat: "plaster", exterior: false };
     }
     const pieceOf = (w) => !w.id ? null : structurePiece(w.id) || pieceRecord(w.id, w.material || "brick", w.role || "partition", { floor: w.floor });
     function nearestWall(f, axis2, L, c) {
       let m = null, md = 1e9;
-      for (const w of shared.ctx.r.walls) {
+      for (const w of shared2.ctx.r.walls) {
         if (w.floor !== f || w.axis !== axis2 || w.type !== "wall" || Math.abs((axis2 === "u" ? w.v0 : w.u0) - L) > EPS6) continue;
         const a = Math.min(axis2 === "u" ? w.u0 : w.v0, axis2 === "u" ? w.u1 : w.v1), b = Math.max(axis2 === "u" ? w.u0 : w.v0, axis2 === "u" ? w.u1 : w.v1), d = c < a ? a - c : c > b ? c - b : 0;
         if (d < md) {
@@ -28929,7 +29034,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       return m;
     }
     function walls() {
-      const R = shared.ctx.r, cut = shared.ctx.cut, nA = R.floors.length, vMin = Math.min(...R.walls.map((w) => w.axis === "u" ? w.v0 : Math.min(w.v0, w.v1)));
+      const R = shared2.ctx.r, cut = shared2.ctx.cut, nA = R.floors.length, vMin = Math.min(...R.walls.map((w) => w.axis === "u" ? w.v0 : Math.min(w.v0, w.v1)));
       const corners = /* @__PURE__ */ new Map();
       for (const w of R.walls) {
         const f = w.floor;
@@ -28940,9 +29045,9 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         const hh = cut ? Math.min(h, 1.2) : h, L = alongU ? w.v0 : w.u0, s0 = Math.min(alongU ? w.u0 : w.v0, alongU ? w.u1 : w.v1), s1 = Math.max(alongU ? w.u0 : w.v0, alongU ? w.u1 : w.v1);
         const front = alongU && Math.abs(L - vMin) < 0.05;
         const sideL = sideOf(w.sides[0], front), sideH = sideOf(w.sides[1], front);
-        shared.ctx.colliders.push({ type: "wall", piece: w.id, f, x0: alongU ? s0 : L - th / 2, z0: alongU ? L - th / 2 : s0, x1: alongU ? s1 : L + th / 2, z1: alongU ? L + th / 2 : s1 });
+        shared2.ctx.colliders.push({ type: "wall", piece: w.id, f, x0: alongU ? s0 : L - th / 2, z0: alongU ? L - th / 2 : s0, x1: alongU ? s1 : L + th / 2, z1: alongU ? L + th / 2 : s1 });
         if (w.type === "railing") {
-          const c0 = shared.ctx.colors.metal != null ? shared.ctx.colors.metal : 9080466;
+          const c0 = shared2.ctx.colors.metal != null ? shared2.ctx.colors.metal : 9080466;
           const sx = alongU ? 1 : 0, sz = alongU ? 0 : 1, len = s1 - s0, n = Math.max(1, Math.round(len / 1.4));
           const cx_ = alongU ? (s0 + s1) / 2 : L, cz_ = alongU ? L : (s0 + s1) / 2;
           boxC("glass", cx_, y0 + 0.55, cz_, alongU ? len : 0.02, 0.85, alongU ? 0.02 : len, 16777215);
@@ -28989,7 +29094,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     }
     Object.assign(K, { wallBox, sideOf, pieceOf, nearestWall, walls });
   }
-  function installHouseDoors(K, shared) {
+  function installHouseDoors(K, shared2) {
     const seedKey = (id) => K.seedKey(id);
     const { EPS: EPS6, Y0, boxC, bx, cursor, effectiveHeight, nearestWall, part, pieceOf, pieceRecord, roomAt, sideOf, wallBox } = K;
     const SEED = (...a) => K.SEED(...a);
@@ -28997,15 +29102,15 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     const rngString = (...a) => K.rngString(...a);
     const sh = (...a) => K.sh(...a);
     function doorLineSides(p) {
-      const R = shared.ctx.r, alongU = p.axis === "u", a = p.at - p.width / 2, b = p.at + p.width / 2;
+      const R = shared2.ctx.r, alongU = p.axis === "u", a = p.at - p.width / 2, b = p.at + p.width / 2;
       const w = R.walls.find((w2) => w2.floor === p.floor && w2.axis === p.axis && Math.abs((alongU ? w2.v0 : w2.u0) - p.pos) < EPS6 && w2.type === "wall" && (Math.abs((alongU ? w2.u1 : w2.v1) - a) < 0.02 || Math.abs((alongU ? w2.u0 : w2.v0) - b) < 0.02));
       const sides = w ? w.sides : [p.a, p.b];
       return [sideOf(sides[0], false), sideOf(sides[1], false)];
     }
-    shared.doorState = /* @__PURE__ */ new Map();
+    shared2.doorState = /* @__PURE__ */ new Map();
     function doors() {
-      shared.ctx.leaves = [];
-      const R = shared.ctx.r, cut = shared.ctx.cut, C = shared.ctx.colors, wood = C.wood != null ? C.wood : 8016948, frame2 = sh(wood, 0.55);
+      shared2.ctx.leaves = [];
+      const R = shared2.ctx.r, cut = shared2.ctx.cut, C = shared2.ctx.colors, wood = C.wood != null ? C.wood : 8016948, frame2 = sh(wood, 0.55);
       for (const p of R.doors) {
         const f = p.floor;
         cursor.group = "f" + f;
@@ -29035,12 +29140,12 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         }
         const leaf = (u0, u1, y_0, y_1, tt, color2, mat = "wood") => alongU ? bx(mat, u0, y0 + y_0, L - tt / 2, u1, y0 + y_1, L + tt / 2, color2) : bx(mat, L - tt / 2, y0 + y_0, u0, L + tt / 2, y0 + y_1, u1, color2);
         const extC = wood;
-        const open0 = p.blocked ? false : shared.doorState.has(p.id) ? shared.doorState.get(p.id) : !!p.open;
-        shared.doorState.set(p.id, open0);
+        const open0 = p.blocked ? false : shared2.doorState.has(p.id) ? shared2.doorState.get(p.id) : !!p.open;
+        shared2.doorState.set(p.id, open0);
         const dc = alongU ? [p.at, L] : [L, p.at];
         const fo = { id: p.id, floor: f, type: p.model === "steel" ? "steel" : "swing", open: open0, t: open0 ? 1 : 0, blockedFlag: !!p.blocked, locked: R.state === "fortified" && !!p.exterior, handleNames: [], hT: 0, cx: dc[0], cz: dc[1], visH, groups: [], col: null };
         const colR = { type: "door", f, x0: alongU ? a : L - th / 2, z0: alongU ? L - th / 2 : a, x1: alongU ? b : L + th / 2, z1: alongU ? L + th / 2 : b, off: open0 };
-        shared.ctx.colliders.push(colR);
+        shared2.ctx.colliders.push(colR);
         fo.col = colR;
         const leafBox = (hu, d0, d1, y_0, y_1, tt, color2, mat) => alongU ? bx(mat, d0, y_0, -tt / 2, d1, y_1, tt / 2, color2) : bx(mat, -tt / 2, y_0, d0, tt / 2, y_1, d1, color2);
         const newGroup = (k, hu, topY) => {
@@ -29100,7 +29205,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
             fo.rot = Math.atan2(n[0] * A[1] - n[1] * A[0], A[0] * n[0] + A[1] * n[1]);
           }
         }
-        shared.ctx.leaves.push(fo);
+        shared2.ctx.leaves.push(fo);
         cursor.group = "f" + f;
         if (p.blocked) {
           part("window_boards", [0, 0, 0], () => {
@@ -29128,18 +29233,18 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
               }
             }
           }, { id: "boards:" + p.id }, "f" + f);
-          shared.ctx.colliders.push({ type: "board", f, x0: alongU ? a : L - th / 2, z0: alongU ? L - th / 2 : a, x1: alongU ? b : L + th / 2, z1: alongU ? L + th / 2 : b });
+          shared2.ctx.colliders.push({ type: "board", f, x0: alongU ? a : L - th / 2, z0: alongU ? L - th / 2 : a, x1: alongU ? b : L + th / 2, z1: alongU ? L + th / 2 : b });
         }
       }
     }
     Object.assign(K, { doorLineSides, doors });
   }
-  function installHouseWindows(K, shared) {
+  function installHouseWindows(K, shared2) {
     const { EPS: EPS6, Y0, boxC, bx, cursor, pieceRecord, roomAt } = K;
     const FRAME_COLORS = { budget: 15856110, mid: 12830924, high: 2829875, commercial: 11844287 };
     const SILL_COLORS = { budget: 15131870, mid: 14277076, high: 3816770, commercial: 13225166 };
     function windows() {
-      const R = shared.ctx.r, cut = shared.ctx.cut, C = shared.ctx.colors, structure = R.style, fr = FRAME_COLORS[structure] || FRAME_COLORS.budget, pe_ = SILL_COLORS[structure] || SILL_COLORS.budget;
+      const R = shared2.ctx.r, cut = shared2.ctx.cut, C = shared2.ctx.colors, structure = R.style, fr = FRAME_COLORS[structure] || FRAME_COLORS.budget, pe_ = SILL_COLORS[structure] || SILL_COLORS.budget;
       const boardItems = new Set(R.stateItems.filter((e) => e.type === "window_boards" && e.window).map((e) => e.window));
       for (const j of R.windows) {
         const f = j.floor;
@@ -29192,11 +29297,11 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     }
     Object.assign(K, { FRAME_COLORS, SILL_COLORS, windows });
   }
-  function installHouseFloors(K, shared) {
+  function installHouseFloors(K, shared2) {
     const { rectsOf: rectsOf2, EPS: EPS6, OPEN_AREA, Y0, bx, cursor, floorColor, stairFootprint, structurePiece, subRects } = K;
     function flights() {
-      if (shared.ctx._flights && shared.ctx._flights.r === shared.ctx.r) return shared.ctx._flights.l;
-      const R = shared.ctx.r, mp = /* @__PURE__ */ new Map();
+      if (shared2.ctx._flights && shared2.ctx._flights.r === shared2.ctx.r) return shared2.ctx._flights.l;
+      const R = shared2.ctx.r, mp = /* @__PURE__ */ new Map();
       for (const m of R.items) {
         if (m.type !== "stairs" || !m.link) continue;
         const k = [m.link.from, m.link.to, m.x.toFixed(2), m.z.toFixed(2), (m.ry || 0).toFixed(2)].join("|");
@@ -29212,12 +29317,12 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         v.LP = LP;
         v.top = stairFootprint({ x: m.x + lz * Math.sin(m.ry), z: m.z + lz * Math.cos(m.ry), ry: m.ry, w: m.w, d: LP });
       }
-      shared.ctx._flights = { r: R, l };
+      shared2.ctx._flights = { r: R, l };
       return l;
     }
     const panelRects = (p) => p.footprint && p.footprint.length ? p.footprint : [p.aabb];
     function tilesOf(parent, rc) {
-      const ps = parent && shared.ctx.panelsOf && shared.ctx.panelsOf.get(parent);
+      const ps = parent && shared2.ctx.panelsOf && shared2.ctx.panelsOf.get(parent);
       if (!ps) return [[parent ? structurePiece(parent) : null, rc]];
       const out = [], taken = [];
       for (const p of ps) for (const q of panelRects(p)) {
@@ -29231,14 +29336,14 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       return out;
     }
     function panelAt(parent, x, z) {
-      const ps = shared.ctx.panelsOf && shared.ctx.panelsOf.get(parent);
+      const ps = shared2.ctx.panelsOf && shared2.ctx.panelsOf.get(parent);
       if (!ps) return structurePiece(parent);
       for (const p of ps) for (const q of panelRects(p)) if (x >= q[0] - EPS6 && x <= q[2] + EPS6 && z >= q[1] - EPS6 && z <= q[3] + EPS6) return structurePiece(p.id);
       return null;
     }
-    const hasSlab = (id) => !!(shared.ctx.structureIndex[id] || shared.ctx.panelsOf && shared.ctx.panelsOf.has(id));
+    const hasSlab = (id) => !!(shared2.ctx.structureIndex[id] || shared2.ctx.panelsOf && shared2.ctx.panelsOf.has(id));
     function floorsAndSlabs() {
-      const R = shared.ctx.r, nA = R.floors.length, C = shared.ctx.colors;
+      const R = shared2.ctx.r, nA = R.floors.length, C = shared2.ctx.colors;
       const V3 = flights(), holes = (f) => V3.filter((v) => v.to === f).flatMap((v) => {
         let rs = [v.rect];
         if (v.top) rs = subRects(rs, [v.top]);
@@ -29275,18 +29380,18 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     }
     Object.assign(K, { flights, floorsAndSlabs, tilesOf, panelAt });
   }
-  function installHouseStairs(K, shared) {
+  function installHouseStairs(K, shared2) {
     const { rectsOf: rectsOf2, Y0, boxC, bx, cursor, flights, stairFootprint, structurePiece } = K;
     const sh = (...a) => K.sh(...a);
     function buildStairs() {
-      const R = shared.ctx.r;
-      shared.ctx.stairs = [];
+      const R = shared2.ctx.r;
+      shared2.ctx.stairs = [];
       for (const vo of flights()) {
         const m = vo.m, f = vo.from, Dr = m.d - (vo.LP || 0);
         cursor.group = "f" + f;
         cursor.pc = structurePiece("stairs_" + vo.from + "_" + vo.to);
         const y0 = Y0(f), H = Y0(m.link.to) - y0, n = Math.max(8, Math.round(H / 0.18)), c = Math.cos(m.ry), s = Math.sin(m.ry);
-        const wood = shared.ctx.colors.wood != null ? shared.ctx.colors.wood : 9071176, under = sh(wood, 0.7);
+        const wood = shared2.ctx.colors.wood != null ? shared2.ctx.colors.wood : 9071176, under = sh(wood, 0.7);
         const P = (lx, lz) => [m.x + lx * c + lz * s, m.z - lx * s + lz * c];
         const boxL = (mat, lx, y, lz, w, h, d, color2, rx = 0) => {
           const [px, pz] = P(lx, lz);
@@ -29308,16 +29413,16 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
           }
         }
         cursor.pc = null;
-        shared.ctx.stairs.push({ m, f, to: vo.to, y0, H, rect: stairFootprint(m), landingPoint: (vo.LP || 0) / m.d });
+        shared2.ctx.stairs.push({ m, f, to: vo.to, y0, H, rect: stairFootprint(m), landingPoint: (vo.LP || 0) / m.d });
       }
     }
     function elevator() {
-      const R = shared.ctx.r;
+      const R = shared2.ctx.r;
       for (const c of R.rooms.filter((c2) => c2.type === "elevator" && c2.floor === 0)) {
         cursor.group = "f0";
         const [u0, v0, u1, v1] = rectsOf2(c)[0], y0 = Y0(0);
         bx("metal", u0 + 0.15, y0 + 0.05, v0 + 0.15, u1 - 0.15, y0 + 2.3, v1 - 0.15, 10133670);
-        bx("emissive", u0 + 0.3, y0 + 2.28, v0 + 0.3, u1 - 0.3, y0 + 2.3, v1 - 0.3, shared.ctx.night ? 16773320 : 13619924);
+        bx("emissive", u0 + 0.3, y0 + 2.28, v0 + 0.3, u1 - 0.3, y0 + 2.3, v1 - 0.3, shared2.ctx.night ? 16773320 : 13619924);
         for (const f of R.floors) {
           const yy = Y0(f.index);
           cursor.group = "f" + f.index;
@@ -29327,7 +29432,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     }
     Object.assign(K, { buildStairs, elevator });
   }
-  function installLightsFixtures(K, shared) {
+  function installLightsFixtures(K, shared2) {
     const seedKey = (id) => K.seedKey(id);
     const { cursor, part, polyFace } = K;
     const makeApi = (...a) => K.makeApi(...a);
@@ -29345,9 +29450,9 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         return ((t ^ t >>> 14) >>> 0) / 4294967296;
       };
     }
-    const SEED = () => shared.ctx.r && shared.ctx.r.seed || 0;
-    const STYLE = () => shared.ctx.r && shared.ctx.r.style || "budget";
-    shared.api0 = null;
+    const SEED = () => shared2.ctx.r && shared2.ctx.r.seed || 0;
+    const STYLE = () => shared2.ctx.r && shared2.ctx.r.style || "budget";
+    shared2.api0 = null;
     function kit2(M, A, y0 = M.y || 0) {
       const c = Math.cos(M.ry), s = Math.sin(M.ry);
       let api = A;
@@ -29379,7 +29484,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
             return null;
           }
           const a0 = api;
-          api = shared.api0 || (shared.api0 = makeApi());
+          api = shared2.api0 || (shared2.api0 = makeApi());
           try {
             return part(type, W(lx, ly, lz), fn, meta || {}, void 0, M.ry);
           } finally {
@@ -29473,7 +29578,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         yLight = yc - 0.3;
         range2 = 6.5;
       } else if (type === "chandelier") {
-        const yc = t - 0.5, gold = shared.ctx.colors && shared.ctx.colors.metal != null ? shared.ctx.colors.metal : 9075290, N = 6;
+        const yc = t - 0.5, gold = shared2.ctx.colors && shared2.ctx.colors.metal != null ? shared2.ctx.colors.metal : 9075290, N = 6;
         K2.c("metal", 0, yc, 0, 0.012, 0.5, gold);
         K2.e("metal", 0, yc - 0.03, 0, 0.055, 0.08, gold);
         K2.c("metal", 0, yc - 0.06, 0, 0.14, 0.015, gold);
@@ -29551,24 +29656,24 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     }
     Object.assign(K, { hashString, rngString, SEED, STYLE, kit2, arcPoints, TEMP_WARM, TEMP_NEUTRAL, TEMP_COOL, colorTemperature, lightStyle, ceilingLamp, tableLamp, floorLamp, sconce, outdoorLamp, lightSwitch });
   }
-  function installLightsDecor(K, shared) {
+  function installLightsDecor(K, shared2) {
     const { EPS: EPS6, OPEN_AREA, SEED, Y0, cursor, rngString, roomAt, stairFootprint } = K;
     const lightItem = (...a) => K.lightItem(...a);
     function decorLights(api) {
-      const R = shared.ctx.r, T2 = shared.ctx.types, structure = R.style, chance = structure === "budget" ? 0.35 : structure === "mid" ? 0.75 : 1, rnd2 = rngString(SEED() + "|decorluz");
+      const R = shared2.ctx.r, T2 = shared2.ctx.types, structure = R.style, chance = structure === "budget" ? 0.35 : structure === "mid" ? 0.75 : 1, rnd2 = rngString(SEED() + "|decorluz");
       const itemsF = (f) => R.items.filter((m) => (m.outdoor ? -1 : m.floor) === f && m.type !== "stairs");
       const rectsF = (f) => itemsF(f).filter((m) => (m.h || 0) > 0.3 && !/rug|floor|concrete|dirt|lawn|ceiling_light|curtain|blinds|picture|mirror|pendant|chandelier|spot/.test(m.type)).map((m) => stairFootprint(m));
       const free = (f, x, z, margin) => {
         if (!roomAt(f, x, z)) return false;
-        for (const c of shared.ctx.colliders) if (c.f === f && x > c.x0 - margin && x < c.x1 + margin && z > c.z0 - margin && z < c.z1 + margin) return false;
+        for (const c of shared2.ctx.colliders) if (c.f === f && x > c.x0 - margin && x < c.x1 + margin && z > c.z0 - margin && z < c.z1 + margin) return false;
         for (const r of rectsF(f)) if (x > r[0] - margin && x < r[2] + margin && z > r[1] - margin && z < r[3] + margin) return false;
         return true;
       };
       const puts = (f, type, m0, extra) => {
         const ent = T2[type];
         if (!ent) return;
-        const com = shared.ctx.roomById[m0.room], g = "f" + f, base = Y0(f);
-        const M = Object.assign({ x: m0.x, z: m0.z, ry: m0.ry || 0, w: m0.w || 0.3, d: m0.d || 0.3, h: m0.h || 0.3, y: 0, base, floor: f, colors: shared.ctx.colors, seed: m0.id, room: m0.room, typeWith: com ? com.type : null, ceiling: com ? com.ceiling : 2.8, on: shared.ctx.night, light: shared.ctx.night, lit: shared.ctx.night }, extra || {});
+        const com = shared2.ctx.roomById[m0.room], g = "f" + f, base = Y0(f);
+        const M = Object.assign({ x: m0.x, z: m0.z, ry: m0.ry || 0, w: m0.w || 0.3, d: m0.d || 0.3, h: m0.h || 0.3, y: 0, base, floor: f, colors: shared2.ctx.colors, seed: m0.id, room: m0.room, typeWith: com ? com.type : null, ceiling: com ? com.ceiling : 2.8, on: shared2.ctx.night, light: shared2.ctx.night, lit: shared2.ctx.night }, extra || {});
         cursor.group = g;
         lightItem({ id: m0.id, room: m0.room }, M, ent, api, g);
       };
@@ -29616,18 +29721,18 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     }
     Object.assign(K, { decorLights });
   }
-  function installLotTerrain(K, shared) {
+  function installLotTerrain(K, shared2) {
     const { rectsOf: rectsOf2, MIRRORS, PARTS, bx, cursor } = K;
     function terrain() {
       PARTS.length = 0;
       MIRRORS.length = 0;
       K.CARS.length = 0;
-      shared.partCount = 0;
-      shared.ctx.parts = {};
-      shared.tapCount = 0;
-      shared.ctx.clotheslines = [];
-      if (shared.ctx.noTerrain) return;
-      const R = shared.ctx.r, lt2 = R.lot, C = shared.ctx.colors;
+      shared2.partCount = 0;
+      shared2.ctx.parts = {};
+      shared2.tapCount = 0;
+      shared2.ctx.clotheslines = [];
+      if (shared2.ctx.noTerrain) return;
+      const R = shared2.ctx.r, lt2 = R.lot, C = shared2.ctx.colors;
       cursor.group = "floor";
       const light = (c, f) => {
         const m = (k) => Math.round((c >> k & 255) * (1 - f) + 255 * f);
@@ -29641,13 +29746,13 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         bx("sidewalk", u0 - 40, -0.06, v0 - 1.8, u1 + 40, 0.02, v0, 14999766);
         for (let x = u0 - 38; x < u1 + 40; x += 6) bx("plaster", x, 0, v0 - 5.6, x + 2.6, 5e-3, v0 - 5.4, 15262904);
       } else {
-        const b = shared.ctx.limits;
+        const b = shared2.ctx.limits;
         bx("sidewalk", b.x0 - 6, -0.09, b.z0 - 6, b.x1 + 6, -0.03, b.z1 + 6, 14605010);
       }
     }
     function freeSpans(alongU, L, a, b) {
       const blocks = [];
-      for (const c of shared.ctx.r.rooms) {
+      for (const c of shared2.ctx.r.rooms) {
         if (c.type === "void" || c.floor < 0) continue;
         for (const [u0, v0, u1, v1] of rectsOf2(c)) {
           const c0 = alongU ? v0 : u0, c1 = alongU ? v1 : u1, lo = alongU ? u0 : v0, hi = alongU ? u1 : v1;
@@ -29667,12 +29772,12 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     }
     Object.assign(K, { terrain, freeSpans });
   }
-  function installLotPerimeter(K, shared) {
+  function installLotPerimeter(K, shared2) {
     const { EPS: EPS6, boxC, bx, colorOf, cursor, freeSpans, pieceRecord } = K;
     const makeApi = (...a) => K.makeApi(...a);
     const sh = (...a) => K.sh(...a);
     function perimeter() {
-      const R = shared.ctx.r, lt2 = R.lot, C = shared.ctx.colors;
+      const R = shared2.ctx.r, lt2 = R.lot, C = shared2.ctx.colors;
       if (!lt2) return;
       cursor.group = "lot";
       const rnd2 = /* @__PURE__ */ (() => {
@@ -29686,7 +29791,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         const th = s.thickness || 0.15, h = s.height, color2 = colorOf(s.color) != null ? colorOf(s.color) : C.wall || 12104874, len = b - a;
         const B = (mat, u0, y0, u1, y1, t, c, off = 0) => alongU ? bx(mat, u0, y0, L + off - t / 2, u1, y1, L + off + t / 2, c) : bx(mat, L + off - t / 2, y0, u0, L + off + t / 2, y1, u1, c);
         const col = { type: "lot_wall", f: -1, x0: alongU ? a : L - th / 2, z0: alongU ? L - th / 2 : a, x1: alongU ? b : L + th / 2, z1: alongU ? L + th / 2 : b };
-        shared.ctx.colliders.push(col);
+        shared2.ctx.colliders.push(col);
         if (s.type === "wall") {
           B("plaster", a, 0, b, h, th, color2);
           B("plaster", a, h, b, h + 0.05, th + 0.06, sh(color2, 1.15));
@@ -29725,7 +29830,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
             const w2 = x1 - x0, cm = (x0 + x1) / 2;
             const M = top === "razor_wire" ? { x: alongU ? cm : L, z: alongU ? L : cm, ry: alongU ? 0 : K.PE, w: w2, d: 0.4, h: 0.4, y: ym, base: 0, floor: -1, colors: C, seed: s.id } : { x: alongU ? cm : L, z: alongU ? L : cm, ry: alongU ? 0 : K.PE, w: w2, d: 0.1, h: 0.3, y: 0, base: ym, floor: -1, colors: C, seed: s.id };
             try {
-              shared.ctx.mv.builders[top](M, api);
+              shared2.ctx.mv.builders[top](M, api);
             } catch (e) {
               console.warn(e);
             }
@@ -29746,7 +29851,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       }
     }
     function paths() {
-      const lt2 = shared.ctx.r.lot;
+      const lt2 = shared2.ctx.r.lot;
       if (!lt2 || !lt2.paths) return;
       cursor.group = "lot";
       for (const c of lt2.paths) {
@@ -29759,14 +29864,14 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     }
     Object.assign(K, { perimeter, paths });
   }
-  function installLotGates(K, shared) {
+  function installLotGates(K, shared2) {
     const { bx, colorOf, cursor, cylBase } = K;
     const sh = (...a) => K.sh(...a);
     function slideDirection(g, lt2) {
       return g.u + g.width / 2 + g.width + 1.2 <= lt2.rect[2] ? 1 : -1;
     }
     function gates() {
-      const R = shared.ctx.r, lt2 = R.lot, C = shared.ctx.colors;
+      const R = shared2.ctx.r, lt2 = R.lot, C = shared2.ctx.colors;
       if (!lt2) return;
       cursor.group = "lot";
       const structure = R.style, auto = structure !== "budget", wall = colorOf("wall") || 12104874, cu = (lt2.rect[0] + lt2.rect[2]) / 2, cz = (lt2.rect[1] + lt2.rect[3]) / 2;
@@ -29840,12 +29945,12 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
             bx("emissive", mx + 0.1, 0.28, zc + sd * 0.452, mx + 0.14, 0.31, zc + sd * 0.455, 6479994);
           }
         }
-        if (!g.open || ped) shared.ctx.colliders.push({ type: "gate", f: -1, x0: a, z0: v - 0.1, x1: b, z1: v + 0.1 });
+        if (!g.open || ped) shared2.ctx.colliders.push({ type: "gate", f: -1, x0: a, z0: v - 0.1, x1: b, z1: v + 0.1 });
       }
     }
     Object.assign(K, { slideDirection, gates });
   }
-  function installRoofRoofs(K, shared) {
+  function installRoofRoofs(K, shared2) {
     const { rectsOf: rectsOf2, EPS: EPS6, OPEN_AREA, Y0, bx, cursor } = K;
     const gutter = (...a) => K.gutter(...a);
     const gutterConfig = (...a) => K.gutterConfig(...a);
@@ -29853,14 +29958,14 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     const sh = (...a) => K.sh(...a);
     const slabs = (...a) => K.slabs(...a);
     function roofs() {
-      const R = shared.ctx.r, F = R.facade, C = shared.ctx.colors, nA = R.floors.length, type = F.roof;
+      const R = shared2.ctx.r, F = R.facade, C = shared2.ctx.colors, nA = R.floors.length, type = F.roof;
       cursor.group = "roof";
-      shared.ctx.roofRects = [];
-      shared.ctx.gutter = gutterConfig();
-      shared.ctx.gutter.ncond = 0;
-      shared.ctx.gutter.nbuz = 0;
-      shared.ctx.gutter.bz = /* @__PURE__ */ new Set();
-      shared.ctx.gutterInfo = { gutters: [], downpipes: [], drains: [] };
+      shared2.ctx.roofRects = [];
+      shared2.ctx.gutter = gutterConfig();
+      shared2.ctx.gutter.ncond = 0;
+      shared2.ctx.gutter.nbuz = 0;
+      shared2.ctx.gutter.bz = /* @__PURE__ */ new Set();
+      shared2.ctx.gutterInfo = { gutters: [], downpipes: [], drains: [] };
       const roofColor = C.roof != null ? C.roof : 11031610, gable = (R.seed | 0) % 2 === 0;
       for (let f = 0; f < nA; f++) {
         const rs = R.rooms.filter((c) => c.floor === f && c.type !== "void" && !c.outbuilding && !OPEN_AREA(c)).flatMap(rectsOf2), up = R.rooms.filter((c) => c.floor === f + 1 && c.type !== "void").flatMap(rectsOf2);
@@ -29883,7 +29988,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
           return Y0(f) + Math.max(...cs.map((c) => c.ceiling)) + 0.2;
         };
         if (type === "slab") {
-          for (let j = 0; j < nz; j++) for (let i = 0; i < nx; i++) if (O(j, i)) shared.ctx.roofRects.push({ f, r: [xs[i], zs[j], xs[i + 1], zs[j + 1]], slab: true, yb: pe(xs[i], zs[j], xs[i + 1], zs[j + 1]) + 0.03 });
+          for (let j = 0; j < nz; j++) for (let i = 0; i < nx; i++) if (O(j, i)) shared2.ctx.roofRects.push({ f, r: [xs[i], zs[j], xs[i + 1], zs[j + 1]], slab: true, yb: pe(xs[i], zs[j], xs[i + 1], zs[j + 1]) + 0.03 });
           slabs(f, xs, zs, O, U, nx, nz, full, pe, C);
           cursor.pc = null;
           continue;
@@ -29906,36 +30011,36 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
             if (U(q.j0 - 1, i)) touchesU[1] = 1;
             if (U(q.j1 + 1, i)) touchesU[3] = 1;
           }
-          shared.ctx.roofRects.push({ f, r: [x0, z0, x1, z1], touchesU });
+          shared2.ctx.roofRects.push({ f, r: [x0, z0, x1, z1], touchesU });
           const ybq = pe(x0, z0, x1, z1);
           roofRect(type, x0, z0, x1, z1, ybq, roofColor, gable && single, F, touchesU);
           cursor.pc = null;
-          if (shared.ctx.gutter.on) gutter(type, f, x0, z0, x1, z1, ybq, touchesU);
+          if (shared2.ctx.gutter.on) gutter(type, f, x0, z0, x1, z1, ybq, touchesU);
         }
       }
-      for (const e of shared.ctx.outbuildingList || []) {
+      for (const e of shared2.ctx.outbuildingList || []) {
         const [x0, z0, x1, z1] = e.aabb, yb = Y0(0) + (e.ceiling || 2.6) + 0.2;
-        shared.ctx.roofRects.push({ f: 0, r: [x0, z0, x1, z1], outbuilding: e.id });
+        shared2.ctx.roofRects.push({ f: 0, r: [x0, z0, x1, z1], outbuilding: e.id });
         if (type === "slab") {
           const c = C.facade != null ? C.facade : 14209216;
           bx("plaster", x0 - 0.08, yb, z0 - 0.08, x1 + 0.08, yb + 0.03, z1 + 0.08, sh(C.ceiling != null ? C.ceiling : 12104876, 0.85));
           for (const [a, b, c2, d] of [[x0 - 0.08, z0 - 0.08, x1 + 0.08, z0 - 0.04], [x0 - 0.08, z1 + 0.04, x1 + 0.08, z1 + 0.08], [x0 - 0.08, z0 - 0.08, x0 - 0.04, z1 + 0.08], [x1 + 0.04, z0 - 0.08, x1 + 0.08, z1 + 0.08]]) bx("plaster", a, yb, b, c2, yb + 0.4, d, c);
           continue;
         }
-        shared.ctx.noPiece = true;
+        shared2.ctx.noPiece = true;
         roofRect(type, x0, z0, x1, z1, yb, roofColor, true, F, [0, 0, 0, 0]);
         cursor.pc = null;
-        shared.ctx.noPiece = false;
-        if (shared.ctx.gutter.on) gutter(type, 0, x0, z0, x1, z1, yb, [0, 0, 0, 0]);
+        shared2.ctx.noPiece = false;
+        if (shared2.ctx.gutter.on) gutter(type, 0, x0, z0, x1, z1, yb, [0, 0, 0, 0]);
       }
     }
     Object.assign(K, { roofs });
   }
-  function installRoofGutters(K, shared) {
+  function installRoofGutters(K, shared2) {
     const { boxC, bx, cursor, roomAt } = K;
     const sh = (...a) => K.sh(...a);
     function gutterConfig() {
-      const R = shared.ctx.r, structure = R.style, high = structure === "high" || structure === "luxury", p = high || structure === "mid" ? 0.6 : 0.3;
+      const R = shared2.ctx.r, structure = R.style, high = structure === "high" || structure === "luxury", p = high || structure === "mid" ? 0.6 : 0.3;
       let h = 2166136261;
       for (const ch of String(R.seed) + "|" + K.seedKey(R.template) + "|calha") h = Math.imul(h ^ ch.charCodeAt(0), 16777619);
       const rnd2 = () => {
@@ -29947,10 +30052,10 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       const draw2 = rnd2() < p, light = rnd2() < 0.6;
       void draw2;
       const on = true;
-      return { on, rnd: rnd2, color: high ? 3816770 : light ? 15527921 : 10857392, bad: (shared.ctx.colors.meta && shared.ctx.colors.meta.state) === "abandoned" || R.state === "abandoned", fallback: false };
+      return { on, rnd: rnd2, color: high ? 3816770 : light ? 15527921 : 10857392, bad: (shared2.ctx.colors.meta && shared2.ctx.colors.meta.state) === "abandoned" || R.state === "abandoned", fallback: false };
     }
     function gutter(type, f, X0, Z0, X1, Z1, yb, touchesU) {
-      const G = shared.ctx.gutter, o = type === "fiber_cement" ? 0.3 : 0.45, x0 = X0 - (touchesU[0] ? 0 : o), x1 = X1 + (touchesU[2] ? 0 : o), z0 = Z0 - (touchesU[1] ? 0 : o), z1 = Z1 + (touchesU[3] ? 0 : o), c = G.color, y = yb - 0.05;
+      const G = shared2.ctx.gutter, o = type === "fiber_cement" ? 0.3 : 0.45, x0 = X0 - (touchesU[0] ? 0 : o), x1 = X1 + (touchesU[2] ? 0 : o), z0 = Z0 - (touchesU[1] ? 0 : o), z1 = Z1 + (touchesU[3] ? 0 : o), c = G.color, y = yb - 0.05;
       const run = (ax, a, b, p, outside, breaks) => {
         const seg2 = (u0, u1, tilt) => {
           const L = u1 - u0, m = (u0 + u1) / 2, dy = tilt ? -Math.abs(tilt) * L * 0.5 : 0;
@@ -29974,7 +30079,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       sides.forEach((l, i) => {
         if (l[0]) run(l[1], l[2], l[3], l[4], l[5], G.bad && !G.fallback && i === larger && (G.fallback = true));
       });
-      const INF = shared.ctx.gutterInfo || (shared.ctx.gutterInfo = { gutters: [], downpipes: [], drains: [] });
+      const INF = shared2.ctx.gutterInfo || (shared2.ctx.gutterInfo = { gutters: [], downpipes: [], drains: [] });
       sides.forEach((l, i) => {
         if (l[0]) INF.gutters.push({ f, side: ["z0", "z1", "x0", "x1"][i], axis: l[1], a: l[2], b: l[3], p: l[4], y });
       });
@@ -30036,7 +30141,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     }
     Object.assign(K, { gutterConfig, gutter, drain });
   }
-  function installRoofSlabs(K, shared) {
+  function installRoofSlabs(K, shared2) {
     const { boxC, bx, cursor, drain, roomAt, structurePiece } = K;
     const sh = (...a) => K.sh(...a);
     function slabs(f, xs, zs, O, U, nx, nz, full, pe, C) {
@@ -30066,15 +30171,15 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         side(free(j, i + 1), x1 + o - t, z0 - ez0, x1 + o, z1 + ez1);
         side(free(j - 1, i), x0 - ex0, z0 - o, x1 + ex1, z0 - o + t);
         side(free(j + 1, i), x0 - ex0, z1 + o - t, x1 + ex1, z1 + o);
-        if (shared.ctx.gutter && shared.ctx.gutter.on) for (const [ok, dx, dz] of [[free(j - 1, i), 0, -1], [free(j + 1, i), 0, 1], [free(j, i - 1), -1, 0], [free(j, i + 1), 1, 0]]) {
+        if (shared2.ctx.gutter && shared2.ctx.gutter.on) for (const [ok, dx, dz] of [[free(j - 1, i), 0, -1], [free(j + 1, i), 0, 1], [free(j, i - 1), -1, 0], [free(j, i + 1), 1, 0]]) {
           const kd = f + ":" + dx + ":" + dz;
-          if (!ok || shared.ctx.gutter.bz.has(kd)) continue;
-          shared.ctx.gutter.bz.add(kd);
-          shared.ctx.gutter.nbuz++;
-          const mx = (x0 + x1) / 2, mz = (z0 + z1) / 2, ex = dx ? dx < 0 ? x0 - o : x1 + o : mx, ez = dz ? dz < 0 ? z0 - o : z1 + o : mz, cc = shared.ctx.gutter.color;
+          if (!ok || shared2.ctx.gutter.bz.has(kd)) continue;
+          shared2.ctx.gutter.bz.add(kd);
+          shared2.ctx.gutter.nbuz++;
+          const mx = (x0 + x1) / 2, mz = (z0 + z1) / 2, ex = dx ? dx < 0 ? x0 - o : x1 + o : mx, ez = dz ? dz < 0 ? z0 - o : z1 + o : mz, cc = shared2.ctx.gutter.color;
           boxC("plain", ex + dx * 0.15, yb + 0.1, ez + dz * 0.15, dx ? 0.42 : 0.14, 0.1, dz ? 0.42 : 0.14, cc);
           boxC("plain", ex + dx * 0.36, yb + 0.1, ez + dz * 0.36, dx ? 0.04 : 0.18, 0.14, dz ? 0.04 : 0.18, sh(cc, 0.8));
-          if (shared.ctx.gutter.bad) boxC("plain", ex + dx * 0.05, yb + 0.5 * 0, ez + dz * 0.05, dx ? 0.06 : 0.3, 0.02, dz ? 0.06 : 0.3, 4868674);
+          if (shared2.ctx.gutter.bad) boxC("plain", ex + dx * 0.05, yb + 0.5 * 0, ez + dz * 0.05, dx ? 0.06 : 0.3, 0.02, dz ? 0.06 : 0.3, 4868674);
           {
             const tx = ex + dx * 0.38, tz = ez + dz * 0.38;
             let lv = true;
@@ -30087,8 +30192,8 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
               boxC("plain", tx, 0.9, tz, 0.12, 0.04, 0.12, sh(cc, 0.8));
               const rx = tx + dx * 0.24, rz = tz + dz * 0.24;
               drain(rx, rz, tx, tz, cc);
-              (shared.ctx.gutterInfo || (shared.ctx.gutterInfo = { gutters: [], downpipes: [], drains: [] })).downpipes.push({ f, x: tx, z: tz, y0: 0.045, y1: yb + 0.04, drain: [rx, rz], hornBox: true });
-              shared.ctx.gutterInfo.drains.push({ x: rx, z: rz });
+              (shared2.ctx.gutterInfo || (shared2.ctx.gutterInfo = { gutters: [], downpipes: [], drains: [] })).downpipes.push({ f, x: tx, z: tz, y0: 0.045, y1: yb + 0.04, drain: [rx, rz], hornBox: true });
+              shared2.ctx.gutterInfo.drains.push({ x: rx, z: rz });
             }
           }
         }
@@ -30096,10 +30201,10 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     }
     Object.assign(K, { slabs });
   }
-  function installRoofTiles(K, shared) {
+  function installRoofTiles(K, shared2) {
     const { UV_SCALE, _Y, _h2, _q, accFor, cursor, put, rgbOf, structurePiece } = K;
     const sh = (...a) => K.sh(...a);
-    const R_STYLE = () => shared.ctx.r && shared.ctx.r.style || "budget";
+    const R_STYLE = () => shared2.ctx.r && shared2.ctx.r.style || "budget";
     function tileRelief(mat, pts, color2, type) {
       const n = pts.length;
       if (n < 3) return;
@@ -30140,7 +30245,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         S.push(rx * ex + ry * ey + rz * ez);
         T2.push(rx * dx + ry * dy + rz * dz);
       }
-      const colonial = type !== "fiber_cement", P = colonial ? 0.2 : 0.177, A = colonial ? 0.032 : 0.0255, seg2 = shared.quality === "game" ? colonial ? 4 : 4 : colonial ? 8 : 6, h = P / seg2;
+      const colonial = type !== "fiber_cement", P = colonial ? 0.2 : 0.177, A = colonial ? 0.032 : 0.0255, seg2 = shared2.quality === "game" ? colonial ? 4 : 4 : colonial ? 8 : 6, h = P / seg2;
       const smin = Math.min(...S), smax = Math.max(...S);
       if (smax - smin < 1e-4) return;
       const xs = new Set(S.map((v) => +v.toFixed(5)));
@@ -30212,9 +30317,9 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       }
     }
     function pieceOfPane(x, z) {
-      if (shared.ctx.noPiece || !shared.ctx.panes.length) return null;
+      if (shared2.ctx.noPiece || !shared2.ctx.panes.length) return null;
       let m = null, md = 1e9;
-      for (const a of shared.ctx.panes) {
+      for (const a of shared2.ctx.panes) {
         const b = a.aabb;
         if (!b) continue;
         const dx = x < b[0] ? b[0] - x : x > b[2] ? x - b[2] : 0, dz = z < b[1] ? b[1] - z : z > b[3] ? z - b[3] : 0, d = Math.hypot(dx, dz) * 1e3 + (b[2] - b[0]) * (b[3] - b[1]) * 1e-3;
@@ -30227,11 +30332,11 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     }
     Object.assign(K, { R_STYLE, tileRelief, ridge, pieceOfPane });
   }
-  function installRoofRect(K, shared) {
+  function installRoofRect(K, shared2) {
     const { R_STYLE, bx, cursor, pieceOfPane, polyFace, ridge, tileRelief } = K;
     const sh = (...a) => K.sh(...a);
     function roofRect(type, X0, Z0, X1, Z1, yb, roofColor, gable, F, touchesU = [0, 0, 0, 0]) {
-      const C = shared.ctx.colors, o = type === "fiber_cement" ? 0.3 : 0.45, x0 = X0 - (touchesU[0] ? 0 : o), x1 = X1 + (touchesU[2] ? 0 : o), z0 = Z0 - (touchesU[1] ? 0 : o), z1 = Z1 + (touchesU[3] ? 0 : o), dx = x1 - x0, dz = z1 - z0, xm = (x0 + x1) / 2, zm = (z0 + z1) / 2;
+      const C = shared2.ctx.colors, o = type === "fiber_cement" ? 0.3 : 0.45, x0 = X0 - (touchesU[0] ? 0 : o), x1 = X1 + (touchesU[2] ? 0 : o), z0 = Z0 - (touchesU[1] ? 0 : o), z1 = Z1 + (touchesU[3] ? 0 : o), dx = x1 - x0, dz = z1 - z0, xm = (x0 + x1) / 2, zm = (z0 + z1) / 2;
       const mat = type === "fiber_cement" ? "fiber_cement" : "tile", tp = type === "fiber_cement" ? 0.2 : 0.5, alongX = dx >= dz, up = [0, 1, 0];
       const Q = (pts) => {
         let cx = 0, cz = 0;
@@ -30269,7 +30374,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       }
       const rm = alongX ? dz / 2 : dx / 2;
       {
-        const rr = shared.ctx.roofRects[shared.ctx.roofRects.length - 1];
+        const rr = shared2.ctx.roofRects[shared2.ctx.roofRects.length - 1];
         if (rr && !rr.yb) Object.assign(rr, { yb, tp, gable: !!gable, alongX, exterior: [x0, z0, x1, z1], rm });
       }
       if (gable) {
@@ -30308,12 +30413,12 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     }
     Object.assign(K, { roofRect });
   }
-  function installMirrors(K, shared) {
+  function installMirrors(K, shared2) {
     const { DOC, THREE, Reflector, MIRRORS, Y0, _Y, roomAt } = K;
-    shared.mirrorEnv = null;
-    shared.mirrorMat = null;
+    shared2.mirrorEnv = null;
+    shared2.mirrorMat = null;
     function mirrorEnv() {
-      if (shared.mirrorEnv) return shared.mirrorEnv;
+      if (shared2.mirrorEnv) return shared2.mirrorEnv;
       const mk = (f) => {
         const c = DOC.createElement("canvas");
         c.width = c.height = 64;
@@ -30349,18 +30454,18 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       const t = new THREE.CubeTexture(faces);
       t.colorSpace = THREE.SRGBColorSpace;
       t.needsUpdate = true;
-      shared.mirrorEnv = t;
-      shared.mirrorMat = new THREE.MeshStandardMaterial({ color: 16054008, metalness: 1, roughness: 0.06, envMap: t, envMapIntensity: 1 });
+      shared2.mirrorEnv = t;
+      shared2.mirrorMat = new THREE.MeshStandardMaterial({ color: 16054008, metalness: 1, roughness: 0.06, envMap: t, envMapIntensity: 1 });
       return t;
     }
     const newMirrorState = () => ({ list: [], active: null, tmp: new THREE.Vector3(), house: null });
-    shared.mirrors = newMirrorState();
+    shared2.mirrors = newMirrorState();
     function assembleMirrors(groups) {
-      shared.mirrors.list.length = 0;
-      shared.mirrors.active = null;
+      shared2.mirrors.list.length = 0;
+      shared2.mirrors.active = null;
       if (!MIRRORS.length) return;
       mirrorEnv();
-      if (shared.quality === "game" || !Reflector) {
+      if (shared2.quality === "game" || !Reflector) {
         const by = /* @__PURE__ */ new Map(), m4 = new THREE.Matrix4(), qy = new THREE.Quaternion(), um = new THREE.Vector3(1, 1, 1), ps = new THREE.Vector3(), nm = new THREE.Matrix3(), v = new THREE.Vector3();
         for (const E of MIRRORS) {
           const geo = new THREE.PlaneGeometry(E.w, E.h);
@@ -30387,7 +30492,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
           g.setAttribute("uv", new THREE.Float32BufferAttribute(B.U, 2));
           g.setIndex(B.I);
           g.computeBoundingSphere();
-          const m = new THREE.Mesh(g, shared.mirrorMat);
+          const m = new THREE.Mesh(g, shared2.mirrorMat);
           m.name = "mirror/environment";
           m.userData.part = "mirror";
           (groups[parent] || (groups[parent] = new THREE.Group())).add(m);
@@ -30402,7 +30507,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         g.userData.part = "mirror";
         g.userData.room = E.room;
         const geo = new THREE.PlaneGeometry(E.w, E.h);
-        const fake = new THREE.Mesh(geo, shared.mirrorMat);
+        const fake = new THREE.Mesh(geo, shared2.mirrorMat);
         fake.userData.part = "mirror";
         fake.name = "mirror/environment";
         g.add(fake);
@@ -30418,27 +30523,27 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
           console.warn("mirror real", e);
         }
         (groups[E.parent] || (groups[E.parent] = new THREE.Group())).add(g);
-        shared.mirrors.list.push({ E, g, fake, real });
+        shared2.mirrors.list.push({ E, g, fake, real });
       }
     }
     function floorAtY(y) {
-      const A = shared.ctx.r.floors;
+      const A = shared2.ctx.r.floors;
       let f = 0;
       for (let i = 0; i < A.length; i++) if (y >= A[i].y0 - 0.2) f = i;
       return f;
     }
     function chooseMirror(camera2) {
-      if (!shared.mirrors.list.length) return;
+      if (!shared2.mirrors.list.length) return;
       let target = null;
-      if (shared.mirrors.house && shared.ctx.r) {
-        shared.mirrors.tmp.copy(camera2.position);
-        shared.mirrors.house.worldToLocal(shared.mirrors.tmp);
-        const f = floorAtY(shared.mirrors.tmp.y), c = roomAt(f, shared.mirrors.tmp.x, shared.mirrors.tmp.z);
-        if (c && shared.mirrors.tmp.y > Y0(f) && shared.mirrors.tmp.y < Y0(f) + 4) {
+      if (shared2.mirrors.house && shared2.ctx.r) {
+        shared2.mirrors.tmp.copy(camera2.position);
+        shared2.mirrors.house.worldToLocal(shared2.mirrors.tmp);
+        const f = floorAtY(shared2.mirrors.tmp.y), c = roomAt(f, shared2.mirrors.tmp.x, shared2.mirrors.tmp.z);
+        if (c && shared2.mirrors.tmp.y > Y0(f) && shared2.mirrors.tmp.y < Y0(f) + 4) {
           let best = 1e9;
-          for (const m of shared.mirrors.list) {
+          for (const m of shared2.mirrors.list) {
             if (m.E.room !== c.id || m.E.floor !== f || !m.g.parent || !m.g.parent.visible) continue;
-            const d = Math.hypot(m.E.x - shared.mirrors.tmp.x, m.E.z - shared.mirrors.tmp.z);
+            const d = Math.hypot(m.E.x - shared2.mirrors.tmp.x, m.E.z - shared2.mirrors.tmp.z);
             if (d < best) {
               best = d;
               target = m;
@@ -30446,9 +30551,9 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
           }
         }
       }
-      if (target === shared.mirrors.active) return;
-      shared.mirrors.active = target;
-      for (const m of shared.mirrors.list) {
+      if (target === shared2.mirrors.active) return;
+      shared2.mirrors.active = target;
+      for (const m of shared2.mirrors.list) {
         const on = m === target && !!m.real;
         if (m.real) m.real.visible = on;
         m.fake.visible = !on;
@@ -30456,7 +30561,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     }
     Object.assign(K, { mirrorEnv, newMirrorState, assembleMirrors, floorAtY, chooseMirror });
   }
-  function installCars(K, shared) {
+  function installCars(K, shared2) {
     const { THREE, FLEET, _Y } = K;
     const CARS = [];
     const CAR_BY_STYLE = Object.assign({
@@ -30482,12 +30587,12 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       return b;
     }
     function carModel(k, seed) {
-      const kc = k + "|" + shared.quality + "|" + (seed || 0);
+      const kc = k + "|" + shared2.quality + "|" + (seed || 0);
       if (CAR_CACHE.has(kc)) return CAR_CACHE.get(kc);
       if (!FLEET) return null;
       let res = null;
       try {
-        const v0 = FLEET.build(k, { quality: shared.quality, seed: seed || 0 }), c = { root: v0.group, g: v0.group };
+        const v0 = FLEET.build(k, { quality: shared2.quality, seed: seed || 0 }), c = { root: v0.group, g: v0.group };
         c.root.updateMatrixWorld(true);
         const inv = new THREE.Matrix4();
         const byMaterial = /* @__PURE__ */ new Map(), tmp = new THREE.Matrix4(), v = new THREE.Vector3(), nm = new THREE.Matrix3(), bb = new THREE.Box3();
@@ -30607,7 +30712,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       return g;
     }
     function assembleCars(groups) {
-      if (shared.quality === "game") return assembleMergedCars(groups);
+      if (shared2.quality === "game") return assembleMergedCars(groups);
       for (const C of CARS) {
         const g = carGroup(C.k, C.w, C.d, C.seed);
         if (!g) continue;
@@ -30660,10 +30765,10 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     }
     Object.assign(K, { CARS, CAR_BY_STYLE, CAR_CACHE, materialSignature, BUCKETS, bucketMaterial, carModel, carGroup, assembleCars, assembleMergedCars });
   }
-  function installHouseBuilding(K, shared) {
+  function installHouseBuilding(K, shared2) {
     const { bx, cursor } = K;
     function building() {
-      const R = shared.ctx.r, P = R.building, C = shared.ctx.colors, N = shared.ctx.pa, uf = shared.ctx.pf, pe = P.ceilingHeight, fa = C.facade != null ? C.facade : 14209216;
+      const R = shared2.ctx.r, P = R.building, C = shared2.ctx.colors, N = shared2.ctx.pa, uf = shared2.ctx.pf, pe = P.ceilingHeight, fa = C.facade != null ? C.facade : 14209216;
       cursor.group = "building";
       const uw = P.unit.w, ud = P.unit.d, un = P.units;
       const unitBox = (u) => {
@@ -30671,7 +30776,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         return [x[0], z[0], x[1], z[1]];
       };
       const un0 = unitBox(un[0]), color2 = P.corridor, hall = P.hall, el = P.elevator.rect, es = P.stairs.rect;
-      const sel = un[shared.ctx.pu] || un[0], selR = unitBox(sel);
+      const sel = un[shared2.ctx.pu] || un[0], selR = unitBox(sel);
       const shell = (rc, y0, y1, thickness = 0.15) => {
         const [a, b, c, d] = rc;
         bx("building", a, y0, b, c, y1, b + thickness, fa);
@@ -30710,11 +30815,11 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       }
       const ytop = N * pe - 0.2;
       bx("plaster", Math.min(hall[0] - 3, color2[0]), ytop, Math.min(un[1] ? unitBox(un[1])[1] : 0, el[1]), Math.max(color2[2], un0[2]), ytop + 0.2, Math.max(un0[3], un[1] ? unitBox(un[1])[3] : 0), 11841704);
-      shared.ctx.limits = { x0: Math.min(hall[0] - 3, color2[0]), z0: Math.min(el[1], un[1] ? unitBox(un[1])[1] : 0), x1: Math.max(color2[2], un0[2]), z1: Math.max(un0[3], un[1] ? unitBox(un[1])[3] : 0) };
+      shared2.ctx.limits = { x0: Math.min(hall[0] - 3, color2[0]), z0: Math.min(el[1], un[1] ? unitBox(un[1])[1] : 0), x1: Math.max(color2[2], un0[2]), z1: Math.max(un0[3], un[1] ? unitBox(un[1])[3] : 0) };
     }
     Object.assign(K, { building });
   }
-  function installUtilitiesWater(K, shared) {
+  function installUtilitiesWater(K, shared2) {
     const { THREE, _Y, _q, cursor, cylBase, part, pieceRecord, put } = K;
     function createWater(r, state) {
       const H = r.utilities.plumbing, cap = H ? +H.capacityL || 0 : 0, ls = { dry: [], full: [] }, points = {}, itemPoint = {};
@@ -30806,14 +30911,14 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     }
     const _v3 = new THREE.Vector3();
     function waterPipes() {
-      const H = shared.ctx.r.utilities.plumbing;
+      const H = shared2.ctx.r.utilities.plumbing;
       if (!H || !H.visibleRuns) return;
-      const nA = shared.ctx.r.floors.length;
+      const nA = shared2.ctx.r.floors.length;
       const groupOf = (c) => c && c.floor >= 0 ? "f" + Math.min(c.floor, nA - 1) : "lot", xyz = (p) => [p[0], p[2], p[1]];
       for (const tr of H.visibleRuns) {
         const pts = tr.points.map(xyz), d = tr.diameter || 0.025;
         if (tr.exposed === "wall") {
-          const pt = H.points.find((p) => p.run === tr.id), com = shared.ctx.roomById[tr.to], g2 = groupOf(com || pt && { floor: pt.floor });
+          const pt = H.points.find((p) => p.run === tr.id), com = shared2.ctx.roomById[tr.to], g2 = groupOf(com || pt && { floor: pt.floor });
           part("wall_pipe", [0, 0, 0], () => {
             for (let i = 0; i + 1 < pts.length; i++) pipe(pts[i], pts[i + 1], d, PIPE_COLOR);
             for (const p of pts) cylBase("plain", p[0], p[1] - d, p[2], d * 0.7, d * 2, PIPE_COLOR);
@@ -30821,7 +30926,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
           continue;
         }
         let g;
-        if (tr.exposed === "tank_outlet") g = shared.ctx.waterTankPos && shared.ctx.waterTankPos.group || "f0";
+        if (tr.exposed === "tank_outlet") g = shared2.ctx.waterTankPos && shared2.ctx.waterTankPos.group || "f0";
         else {
           const pt = H.points.find((p) => p.id === tr.to);
           g = groupOf(pt);
@@ -30837,15 +30942,15 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     }
     Object.assign(K, { createWater, PIPE_COLOR, pipe, _v3, waterPipes });
   }
-  function installUtilitiesElectrical(K, shared) {
+  function installUtilitiesElectrical(K, shared2) {
     const { _Y, _q, _v3, bx, cursor, cylBase, pieceRecord, put } = K;
     const sh = (...a) => K.sh(...a);
     function electricalStructure() {
-      const E = shared.ctx.r.utilities.electrical;
-      shared.ctx.electricalInfo = null;
+      const E = shared2.ctx.r.utilities.electrical;
+      shared2.ctx.electricalInfo = null;
       if (!E) return;
-      const R = shared.ctx.r, nA = R.floors.length, lotGroup = R.lot ? "lot" : "f0", concreteColor = 11973547, iron = 4869200, wireRun = 1842206, info = { pole: null, meter: null, panel: null, conduits: [], outlets: [], switches: [], circuits: E.circuits || [], exposed: !!E.exposed };
-      const en22 = E.serviceEntrance, KV = shared.ctx.iv ? shared.ctx.iv.plane : null;
+      const R = shared2.ctx.r, nA = R.floors.length, lotGroup = R.lot ? "lot" : "f0", concreteColor = 11973547, iron = 4869200, wireRun = 1842206, info = { pole: null, meter: null, panel: null, conduits: [], outlets: [], switches: [], circuits: E.circuits || [], exposed: !!E.exposed };
+      const en22 = E.serviceEntrance, KV = shared2.ctx.iv ? shared2.ctx.iv.plane : null;
       const wireL = (a, b, r_ = 8e-3) => {
         const L = Math.hypot(b[0] - a[0], b[1] - a[1], b[2] - a[2]);
         if (L < 1e-3) return;
@@ -30923,7 +31028,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
           info.conduits.push(t.id);
           continue;
         }
-        const c = circ[t.circuit], com = c && shared.ctx.roomById[c.room];
+        const c = circ[t.circuit], com = c && shared2.ctx.roomById[c.room];
         cursor.group = "f" + Math.max(0, Math.min(nA - 1, com ? com.floor : 0));
         const d = t.diameter || 0.02, P = t.points.map((p) => [p[0], p[2], p[1]]), seg2 = [];
         for (let i = 0; i + 1 < P.length; i++) {
@@ -30941,7 +31046,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       }
       for (const t of E.outlets || []) info.outlets.push({ id: t.id, pos: [t.u, t.y, t.v], normal: [t.frontU || 0, 0, t.frontV || 0], room: t.room, floor: t.floor, type: t.type, voltage: t.voltage });
       for (const t of E.switches || []) info.switches.push({ id: t.id, pos: [t.u, t.y, t.v], normal: [t.frontU || 0, 0, t.frontV || 0], room: t.room, floor: t.floor, controls: t.controls });
-      shared.ctx.electricalInfo = info;
+      shared2.ctx.electricalInfo = info;
     }
     function pipe2(a, b, diameter, color2) {
       const dx = b[0] - a[0], dy = b[1] - a[1], dz = b[2] - a[2], L = Math.hypot(dx, dy, dz);
@@ -30951,11 +31056,11 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     }
     Object.assign(K, { electricalStructure, pipe2 });
   }
-  function installHouseBaseboard(K, shared) {
+  function installHouseBaseboard(K, shared2) {
     const { Y0, bx, cursor, sideOf } = K;
     const sh = (...a) => K.sh(...a);
     function baseboardAndSidewalk() {
-      const R = shared.ctx.r, W = 0.6, t = 0.012, ht = 0.35, color2 = sh(shared.ctx.colors.facade != null ? shared.ctx.colors.facade : 14209216, 0.62), y0 = Y0(0), cal = 13947078;
+      const R = shared2.ctx.r, W = 0.6, t = 0.012, ht = 0.35, color2 = sh(shared2.ctx.colors.facade != null ? shared2.ctx.colors.facade : 14209216, 0.62), y0 = Y0(0), cal = 13947078;
       const ws = R.walls.filter((w) => w.floor === 0 && w.type === "wall").map((w) => {
         const au = w.axis === "u";
         return { w, au, L: au ? w.v0 : w.u0, a: Math.min(au ? w.u0 : w.v0, au ? w.u1 : w.v1), b: Math.max(au ? w.u0 : w.v0, au ? w.u1 : w.v1), th: w.thickness || 0.15 };
@@ -30987,11 +31092,11 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     }
     Object.assign(K, { baseboardAndSidewalk });
   }
-  function installUtilitiesSolar(K, shared) {
+  function installUtilitiesSolar(K, shared2) {
     const { Y0, boxC, bx, cursor, cylBase } = K;
     function roofHeightAt(u, v, f) {
       let y = null;
-      for (const rr of shared.ctx.roofRects || []) {
+      for (const rr of shared2.ctx.roofRects || []) {
         if (rr.yb == null || f != null && rr.f !== f) continue;
         if (rr.slab) {
           const [a, b, c, d] = rr.r;
@@ -31006,8 +31111,8 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       return y;
     }
     function solar() {
-      const R = shared.ctx.r, S = R.utilities.solar;
-      shared.ctx.solarInfo = null;
+      const R = shared2.ctx.r, S = R.utilities.solar;
+      shared2.ctx.solarInfo = null;
       if (!S || !S.panels || !S.panels.length) return;
       cursor.group = "roof";
       const silver = 13225426, blue = 1780302, line = 9279142, sv = S.north === "front" ? -1 : 1, info = { type: S.type, panels: [], inverter: null }, onRack = S.type === "slab_rack";
@@ -31049,15 +31154,15 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
           bx("plain", iv.u - W * 0.6, y0 + 0.05, iv.v + fa0, iv.u + W * 0.6, y0 + 0.17, iv.v + fa1, 2106924);
           bx("emissive", iv.u - 0.03, y0 - 0.12, iv.v + fa0, iv.u + 0.03, y0 - 0.09, iv.v + fa1, 6479994);
         }
-        const top = Math.max(...(shared.ctx.roofRects || []).filter((t2) => t2.yb != null).map((t2) => t2.yb), Y0(fa) + 2.8);
+        const top = Math.max(...(shared2.ctx.roofRects || []).filter((t2) => t2.yb != null).map((t2) => t2.yb), Y0(fa) + 2.8);
         cylBase("plain", iv.u, y0 + h / 2, iv.v, 0.016, Math.max(0.2, top - 0.2 - (y0 + h / 2)), 15262936);
         info.inverter = { id: iv.id, pos: [iv.u, y0, iv.v], side: iv.side, link: iv.link };
       }
-      shared.ctx.solarInfo = info;
+      shared2.ctx.solarInfo = info;
     }
     Object.assign(K, { roofHeightAt, solar });
   }
-  function installHouseOutbuildings(K, shared) {
+  function installHouseOutbuildings(K, shared2) {
     const { t, bx, cursor, floorColor } = K;
     const sh = (...a) => K.sh(...a);
     const OUTBUILDING_USE = { guest_room: ["bedroom", "bedroom", t("outbuilding.guest_room")], office: ["office", "office", t("outbuilding.office")], storage: ["stockroom", "stockroom", t("outbuilding.storage")], gourmet: ["living", "gourmet", t("outbuilding.gourmet")] };
@@ -31089,17 +31194,17 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       return Object.assign({}, r, { rooms, walls, doors, windows, items });
     }
     function outbuildings() {
-      const E = (shared.ctx.r.outbuildings || []).filter((e) => shared.ctx.roomById[e.id] && shared.ctx.roomById[e.id].outbuilding);
-      shared.ctx.outbuildingList = E;
+      const E = (shared2.ctx.r.outbuildings || []).filter((e) => shared2.ctx.roomById[e.id] && shared2.ctx.roomById[e.id].outbuilding);
+      shared2.ctx.outbuildingList = E;
       if (!E.length) return;
       cursor.group = "f0";
       for (const e of E) {
-        const c = shared.ctx.roomById[e.id], col = floorColor(c);
+        const c = shared2.ctx.roomById[e.id], col = floorColor(c);
         for (const [a, b, c2, d] of e.interior) bx("plaster", a - 0.075, 0, b - 0.075, c2 + 0.075, 0.04, d + 0.075, col);
         for (const p of e.doors || []) {
           const alongU = p.axis === "u", th = e.thickness || 0.15;
-          if (alongU) bx("plaster", p.at - p.width / 2, 0, p.pos - th / 2 - 0.12, p.at + p.width / 2, 0.03, p.pos + th / 2 + 0.12, sh(shared.ctx.colors.facade || 14209216, 0.8));
-          else bx("plaster", p.pos - th / 2 - 0.12, 0, p.at - p.width / 2, p.pos + th / 2 + 0.12, 0.03, p.at + p.width / 2, sh(shared.ctx.colors.facade || 14209216, 0.8));
+          if (alongU) bx("plaster", p.at - p.width / 2, 0, p.pos - th / 2 - 0.12, p.at + p.width / 2, 0.03, p.pos + th / 2 + 0.12, sh(shared2.ctx.colors.facade || 14209216, 0.8));
+          else bx("plaster", p.pos - th / 2 - 0.12, 0, p.at - p.width / 2, p.pos + th / 2 + 0.12, 0.03, p.at + p.width / 2, sh(shared2.ctx.colors.facade || 14209216, 0.8));
         }
       }
     }
@@ -31833,10 +31938,10 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     }
     Object.assign(K, { typeTable });
   }
-  function installFurnitureTaps(K, shared) {
-    shared.tapCount = 0;
+  function installFurnitureTaps(K, shared2) {
+    shared2.tapCount = 0;
     function counterTap(K2, x, y, z, reach, back, meta = {}) {
-      const cr = 12896460, id = "tap_" + (K2.M.seed || "") + "_" + shared.tapCount++;
+      const cr = 12896460, id = "tap_" + (K2.M.seed || "") + "_" + shared2.tapCount++;
       K2.c("metal", x, y, z, 0.028, 0.012, cr);
       K2.c("metal", x, y + 0.012, z, 0.014, 0.12, cr);
       const pts = [];
@@ -31867,7 +31972,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       return id;
     }
     function wallTap(K2, x, y, zw, direction, back, meta = {}) {
-      const cr = 12896460, id = "tap_" + (K2.M.seed || "") + "_" + shared.tapCount++, s = direction || 1;
+      const cr = 12896460, id = "tap_" + (K2.M.seed || "") + "_" + shared2.tapCount++, s = direction || 1;
       K2.t("metal", [x, y, zw], [x, y, zw + s * 0.025], 0.03, cr);
       K2.t("metal", [x, y, zw + s * 0.02], [x, y, zw + s * 0.1], 0.016, cr);
       K2.e("metal", x, y, zw + s * 0.105, 0.019, 0.04, cr);
@@ -32117,7 +32222,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     }
     Object.assign(K, { GREENS: GREENS2, FLOWERS, blobs, potModel, arcLeaf, tuft, palm_tree, treeModel, shrubModel, potPlant, tablePot, planterModel });
   }
-  function installFurnitureYard(K, shared) {
+  function installFurnitureYard(K, shared2) {
     const seedKey = (id) => K.seedKey(id);
     const { FURNITURE, SEED, STYLE, kit2, rngString, sh, wallTap } = K;
     FURNITURE.laundry_tub = function(M, A) {
@@ -32207,7 +32312,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
           }
         }
       }, { id: "laundry_" + M.seed, swing: true, room: "yard" });
-      (shared.ctx.clotheslines || (shared.ctx.clotheslines = [])).push(M.seed);
+      (shared2.ctx.clotheslines || (shared2.ctx.clotheslines = [])).push(M.seed);
     };
     FURNITURE.water_tank = function(M, A) {
       const K2 = kit2(M, A), w = M.w || 1, d = M.d || 1, onGround = !M.onSlab && (M.y || 0) < 0.5, color2 = M.palette && M.palette.tank_water != null ? M.palette.tank_water : 3107496, r = Math.min(w, d) * 0.46, rc = 11841700;
@@ -32349,13 +32454,13 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     }
     Object.assign(K, { extraTypes });
   }
-  function installFurniturePlaceItems(K, shared) {
+  function installFurniturePlaceItems(K, shared2) {
     const { THREE, Y0, _col, boxC, colorOf, cursor, decorLights, makeApi, structurePiece } = K;
     const buildItem2 = (...a) => K.buildItem(...a);
     const registerCollision = (...a) => K.registerCollision(...a);
     const vegItem = (...a) => K.vegItem(...a);
     function houseItems() {
-      const R = shared.ctx.r, T2 = shared.ctx.types, api = makeApi(), noModel = /* @__PURE__ */ new Map();
+      const R = shared2.ctx.r, T2 = shared2.ctx.types, api = makeApi(), noModel = /* @__PURE__ */ new Map();
       const list2 = R.items.concat(R.stateItems.filter((e) => e.w != null && e.d != null && e.type !== "razor_wire" && e.type !== "barbed_wire"));
       const rect = (poly) => {
         let a = 0;
@@ -32367,8 +32472,8 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         if (m.type === "stairs") continue;
         const exterior = m.outdoor || m.floor < 0, f = exterior ? -1 : Math.min(m.floor, R.floors.length - 1);
         cursor.group = exterior ? "lot" : "f" + f;
-        const com = shared.ctx.roomById[m.room], base = exterior ? 0 : Y0(f);
-        const M = { x: m.x, z: m.z, ry: m.ry || 0, w: m.w, d: m.d, h: m.h, y: m.y || 0, base, floor: exterior ? -1 : f, palette: shared.ctx.colors, color: m.category === "ground_cover" ? void 0 : colorOf(m.color) != null ? colorOf(m.color) : void 0, seed: m.id, room: m.room, typeWith: com ? com.type : null, ceiling: com ? com.ceiling : 2.9, on: shared.ctx.night, light: shared.ctx.night, lit: shared.ctx.night, open: !!m.doorOpen, overhead: m.overhead, assembly: m.assembly, hose: m.hose };
+        const com = shared2.ctx.roomById[m.room], base = exterior ? 0 : Y0(f);
+        const M = { x: m.x, z: m.z, ry: m.ry || 0, w: m.w, d: m.d, h: m.h, y: m.y || 0, base, floor: exterior ? -1 : f, palette: shared2.ctx.colors, color: m.category === "ground_cover" ? void 0 : colorOf(m.color) != null ? colorOf(m.color) : void 0, seed: m.id, room: m.room, typeWith: com ? com.type : null, ceiling: com ? com.ceiling : 2.9, on: shared2.ctx.night, light: shared2.ctx.night, lit: shared2.ctx.night, open: !!m.doorOpen, overhead: m.overhead, assembly: m.assembly, hose: m.hose };
         if (m.category === "ground_cover" && m.polygon) {
           const xs = m.polygon.map((p) => p[0]), zs = m.polygon.map((p) => p[1]);
           M.x = (Math.min(...xs) + Math.max(...xs)) / 2;
@@ -32378,8 +32483,8 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
           M.ry = 0;
           if (!rect(m.polygon)) M.poly = m.polygon.map((p) => [p[0] - M.x, p[1] - M.z]);
         }
-        if (shared.ctx.veg && vegItem(m, M, exterior ? "lot" : "f" + f)) continue;
-        if (shared.ctx.iv && shared.ctx.iv.replace.has(m.id)) {
+        if (shared2.ctx.veg && vegItem(m, M, exterior ? "lot" : "f" + f)) continue;
+        if (shared2.ctx.iv && shared2.ctx.iv.replace.has(m.id)) {
           registerCollision(m, M);
           continue;
         }
@@ -32411,13 +32516,13 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       return noModel;
     }
     function waterTankOfHouse(api) {
-      const cd = shared.ctx.r.waterTank;
-      if (!cd || !shared.ctx.types.water_tank) return;
-      const lc = cd.place === "raised_slab" && cd.platform, slab = cd.place === "slab" || !!lc, nA = shared.ctx.r.floors.length, f = Math.max(0, Math.min(nA - 1, cd.floor));
-      const base = lc ? cd.platform.topY : cd.y + (shared.ctx.r.rooms.some((c) => c.id === cd.room && c.type === "terrace") ? 0 : 0.2 + (slab ? 0.03 : 0));
+      const cd = shared2.ctx.r.waterTank;
+      if (!cd || !shared2.ctx.types.water_tank) return;
+      const lc = cd.place === "raised_slab" && cd.platform, slab = cd.place === "slab" || !!lc, nA = shared2.ctx.r.floors.length, f = Math.max(0, Math.min(nA - 1, cd.floor));
+      const base = lc ? cd.platform.topY : cd.y + (shared2.ctx.r.rooms.some((c) => c.id === cd.room && c.type === "terrace") ? 0 : 0.2 + (slab ? 0.03 : 0));
       cursor.group = slab ? "f" + f : "attic_tank";
       if (lc) {
-        const P = cd.platform, [x0, z0, x1, z1] = P.aabb, e = P.thickness, color2 = shared.ctx.colors.slab != null ? shared.ctx.colors.slab : 12170668;
+        const P = cd.platform, [x0, z0, x1, z1] = P.aabb, e = P.thickness, color2 = shared2.ctx.colors.slab != null ? shared2.ctx.colors.slab : 12170668;
         cursor.pc = structurePiece("tank_slab");
         boxC("plain", (x0 + x1) / 2, P.topY - e / 2, (z0 + z1) / 2, x1 - x0, e, z1 - z0, color2, 0, 0, 0);
         P.pillars.forEach((p, k) => {
@@ -32427,13 +32532,13 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         cursor.pc = null;
       }
       if (!slab) {
-        const color2 = shared.ctx.colors.slab != null ? shared.ctx.colors.slab : 12170668, yp = Y0(f), hw = cd.w / 2 + 0.1, hd = cd.d / 2 + 0.1;
+        const color2 = shared2.ctx.colors.slab != null ? shared2.ctx.colors.slab : 12170668, yp = Y0(f), hw = cd.w / 2 + 0.1, hd = cd.d / 2 + 0.1;
         boxC("plain", cd.u, base - 0.06, cd.v, hw * 2, 0.12, hd * 2, color2);
         for (const sx of [-1, 1]) for (const sz of [-1, 1]) boxC("plain", cd.u + sx * (hw - 0.07), (yp + base - 0.12) / 2, cd.v + sz * (hd - 0.07), 0.1, base - 0.12 - yp, 0.1, color2);
       }
-      const M = { x: cd.u, z: cd.v, ry: 0, w: cd.w, d: cd.d, h: cd.h + 0.12, y: 0, base, floor: f, colors: shared.ctx.colors, seed: "water_tank", room: cd.room, onSlab: true, ceiling: 2.9 };
-      shared.ctx.waterTankPos = { x: cd.u, z: cd.v, y: base, group: cursor.group };
-      shared.ctx.types.water_tank.f(M, api);
+      const M = { x: cd.u, z: cd.v, ry: 0, w: cd.w, d: cd.d, h: cd.h + 0.12, y: 0, base, floor: f, colors: shared2.ctx.colors, seed: "water_tank", room: cd.room, onSlab: true, ceiling: 2.9 };
+      shared2.ctx.waterTankPos = { x: cd.u, z: cd.v, y: base, group: cursor.group };
+      shared2.ctx.types.water_tank.f(M, api);
     }
     function hashColor(s) {
       let h = 7;
@@ -32443,11 +32548,11 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     function labeledBox(m, M, group) {
       const color2 = M.color != null ? M.color : hashColor(m.category || m.type), h = Math.max(0.05, m.h || 0.5);
       boxC("plain", m.x, M.base + (m.y || 0) + h / 2, m.z, m.w, h, m.d, color2, 0, m.ry || 0, 0);
-      shared.ctx.labels.push({ pos: new THREE.Vector3(m.x, M.base + (m.y || 0) + h + 0.15, m.z), text: m.type, group, type: "no_model" });
+      shared2.ctx.labels.push({ pos: new THREE.Vector3(m.x, M.base + (m.y || 0) + h + 0.15, m.z), text: m.type, group, type: "no_model" });
     }
     Object.assign(K, { houseItems, waterTankOfHouse, hashColor, labeledBox });
   }
-  function installVegetationBridge(K, shared) {
+  function installVegetationBridge(K, shared2) {
     const seedKey = (id) => K.seedKey(id);
     const { THREE, SEED, rngString } = K;
     const VEG_POT = ["potted_areca", "potted_snake_plant", "potted_fern"], VEG_CACTUS = { cactus_mandacaru: "mandacaru", cactus_palm: "prickly_pear", cactus_crown: "crown_cactus", cactus_xique: "xique_xique", cactus_pot: "potted_cactus" };
@@ -32473,7 +32578,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     for (const k of Object.keys(VEG_CACTUS)) VEG_MAP[k] = [VEG_CACTUS[k]];
     const VEG_PLANTER = { planter_bed: ["rose_bush_red", "rose_bush_pink", "rose_bush_white", "marigold", "periwinkle_pink", "periwinkle_white", "daisy"], planter_bed_small: ["rose_bush_red", "marigold", "periwinkle_pink", "daisy"], garden_bed: ["lawn_tuft", "wild_flowers"] };
     function vegItem(m, M, group) {
-      const V3 = shared.ctx.veg;
+      const V3 = shared2.ctx.veg;
       if (!V3) return false;
       const ids = VEG_MAP[m.type], can2 = VEG_PLANTER[m.type];
       if (!ids && !can2) return false;
@@ -32514,7 +32619,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       return true;
     }
     function assembleVegetation(groups) {
-      const V3 = shared.ctx.veg;
+      const V3 = shared2.ctx.veg;
       if (!V3) return;
       let pl = 0, tri = 0;
       const col = [], lod = [0, 0, 0], mats = V3.mats();
@@ -32537,17 +32642,17 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         for (const c of lot.colliders) col.push(Object.assign({ y: G.y, group: G.group }, c));
         for (let i = 0; i < 3; i++) lod[i] += lot.lodCounts[i];
       }
-      shared.ctx.vegInfo = { plants: pl, triangles: tri, colliders: col, lodCounts: lod, materials: mats };
+      shared2.ctx.vegInfo = { plants: pl, triangles: tri, colliders: col, lodCounts: lod, materials: mats };
     }
     Object.assign(K, { VEG_POT, VEG_CACTUS, VEG_MAP, VEG_PLANTER, vegItem, assembleVegetation });
   }
-  function installInteractionState(K, shared) {
+  function installInteractionState(K, shared2) {
     const { THREE, cfg, colliderChanged, invalidateShadow, invalidate, UV_SCALE, applyPart, texture } = K;
     const ivRoomEffective = (...a) => K.ivRoomEffective(...a);
     const ivRoomLight = (...a) => K.ivRoomLight(...a);
-    shared.partState = /* @__PURE__ */ new Map();
+    shared2.partState = /* @__PURE__ */ new Map();
     const newInteractiveState = () => ({ defs: /* @__PURE__ */ new Map(), items: [], pieces: [], lights: /* @__PURE__ */ new Map(), litRooms: /* @__PURE__ */ new Set(), objs: [], anim: /* @__PURE__ */ new Set(), msg: null, target: null });
-    shared.inter = newInteractiveState();
+    shared2.inter = newInteractiveState();
     const MESSAGE_MS = 2200;
     UV_SCALE.doorWood = 1;
     UV_SCALE.doorPaint = 1;
@@ -32602,15 +32707,15 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     }
     const _EY = new THREE.Vector3(0, 1, 0), _UM3 = new THREE.Vector3(1, 1, 1);
     const hudMessage = (text) => {
-      shared.inter.msg = { text, until: performance.now() + MESSAGE_MS };
+      shared2.inter.msg = { text, until: performance.now() + MESSAGE_MS };
       if (cfg.onMessage) cfg.onMessage(text);
     };
     function definePiece(name, def) {
       def.name = name;
       def.meshes = [];
-      def.t = def.target = shared.partState.has(name) ? shared.partState.get(name) : def.t0 || 0;
-      shared.inter.defs.set(name, def);
-      shared.inter.pieces.push(def);
+      def.t = def.target = shared2.partState.has(name) ? shared2.partState.get(name) : def.t0 || 0;
+      shared2.inter.defs.set(name, def);
+      shared2.inter.pieces.push(def);
       return def;
     }
     const localOf = (M, lx, lz) => {
@@ -32622,7 +32727,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       return true;
     }
     function assembleInteractive(gs) {
-      for (const [name, def] of shared.inter.defs) {
+      for (const [name, def] of shared2.inter.defs) {
         const g = gs[name];
         if (!g) continue;
         delete gs[name];
@@ -32644,13 +32749,13 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         const parent = def.leaf ? def.leaf.gs[def.k] : gs[def.parent] || (gs[def.parent] = new THREE.Group());
         if (parent) parent.add(outer);
         if (def.roomId) {
-          if (!shared.inter.lights.has(def.roomId)) shared.inter.lights.set(def.roomId, []);
-          shared.inter.lights.get(def.roomId).push(def);
+          if (!shared2.inter.lights.has(def.roomId)) shared2.inter.lights.set(def.roomId, []);
+          shared2.inter.lights.get(def.roomId).push(def);
         }
         applyPiece(def);
       }
-      for (const roomId of shared.inter.litRooms) applyLight(roomId);
-      shared.inter.defs.forEach((d) => {
+      for (const roomId of shared2.inter.litRooms) applyLight(roomId);
+      shared2.inter.defs.forEach((d) => {
         if (d.col) d.col.off = d.t > 0.5;
       });
     }
@@ -32690,8 +32795,8 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     }
     const DURATION = { swing: 0.55, drawer: 0.4, curtain: 0.9, gate_swing: 0.9, gate_tilt: 1.4, gate_slide: 1.6, lightSwitch: 0.12, part: 0.4 };
     function animateInteractive(dt) {
-      if (!shared.inter.anim.size) return;
-      for (const p of shared.inter.anim) {
+      if (!shared2.inter.anim.size) return;
+      for (const p of shared2.inter.anim) {
         const step = dt / (DURATION[p.kind] || 0.5), d = p.target - p.t;
         p.t = Math.abs(d) <= step ? p.target : p.t + Math.sign(d) * step;
         applyPiece(p);
@@ -32699,39 +32804,39 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
           p.col.off = p.target > 0.5;
           colliderChanged(p.col);
         }
-        if (p.t === p.target) shared.inter.anim.delete(p);
+        if (p.t === p.target) shared2.inter.anim.delete(p);
       }
       invalidateShadow();
     }
     function togglePiece(p) {
       p.target = p.target > 0.5 ? 0 : 1;
-      shared.partState.set(p.name, p.target);
+      shared2.partState.set(p.name, p.target);
       if (p.col && p.col.off !== p.target > 0.5) {
         p.col.off = p.target > 0.5;
         colliderChanged(p.col);
       }
-      shared.inter.anim.add(p);
+      shared2.inter.anim.add(p);
     }
-    const lightBase = (roomId) => roomId == null ? true : shared.partState.has("light:" + roomId) ? !!shared.partState.get("light:" + roomId) : !!shared.ctx.night;
+    const lightBase = (roomId) => roomId == null ? true : shared2.partState.has("light:" + roomId) ? !!shared2.partState.get("light:" + roomId) : !!shared2.ctx.night;
     const lightOn = (roomId) => {
-      const S = roomId != null && shared.ctx.iv && shared.ctx.iv.roomStates.get(roomId);
+      const S = roomId != null && shared2.ctx.iv && shared2.ctx.iv.roomStates.get(roomId);
       return S ? S.ef : lightBase(roomId);
     };
     function applyLight(roomId) {
       const on = lightOn(roomId);
-      for (const d of shared.inter.lights.get(roomId) || []) for (const m of d.meshes) if (m.name.endsWith("/emissive")) m.material = on ? shared.mats.emissive : shared.mats.off;
-      const sw = shared.inter.defs.get("ix:int:" + roomId);
+      for (const d of shared2.inter.lights.get(roomId) || []) for (const m of d.meshes) if (m.name.endsWith("/emissive")) m.material = on ? shared2.mats.emissive : shared2.mats.off;
+      const sw = shared2.inter.defs.get("ix:int:" + roomId);
       if (sw) {
         sw.target = on ? 1 : 0;
-        if (sw.t !== sw.target) shared.inter.anim.add(sw);
+        if (sw.t !== sw.target) shared2.inter.anim.add(sw);
       }
       invalidate();
     }
     function toggleLight(roomId) {
-      const S = shared.ctx.iv && shared.ctx.iv.roomStates.get(roomId);
+      const S = shared2.ctx.iv && shared2.ctx.iv.roomStates.get(roomId);
       if (S) {
-        ivRoomLight(shared.ctx.iv, roomId, !S.ef);
-        const ef = ivRoomEffective(shared.ctx.iv, S);
+        ivRoomLight(shared2.ctx.iv, roomId, !S.ef);
+        const ef = ivRoomEffective(shared2.ctx.iv, S);
         if (ef !== S.ef) {
           S.ef = ef;
           applyLight(roomId);
@@ -32739,13 +32844,13 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         }
         return;
       }
-      shared.partState.set("light:" + roomId, !lightOn(roomId));
+      shared2.partState.set("light:" + roomId, !lightOn(roomId));
       applyLight(roomId);
       if (cfg.onLight) cfg.onLight(roomId, lightOn(roomId));
     }
     Object.assign(K, { newInteractiveState, MESSAGE_MS, createInteractiveMaterials, _EY, _UM3, hudMessage, definePiece, localOf, visibleChain, assembleInteractive, applyPiece, DURATION, animateInteractive, togglePiece, lightBase, lightOn, applyLight, toggleLight });
   }
-  function installInteractionCollision(K, shared) {
+  function installInteractionCollision(K, shared2) {
     const NO_COLLIDE = /(^|_)(rug|floor|concrete|dirt|lawn|deck|ceiling_light|pendant|chandelier|spot|picture|curtain|blinds|wall_shelving|plank_shelf|wall_ac|ac_condenser|pool|soaking_tub|pergola|stairs|mirror)/;
     function registerCollision(m, M) {
       const h = m.h || 0, y = M.y || 0;
@@ -32755,7 +32860,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         w = Math.min(w, 0.5);
         d = Math.min(d, 0.5);
       }
-      shared.inter.objs.push({ f: M.floor, cx: m.x, cz: m.z, c: Math.cos(M.ry), s: Math.sin(M.ry), hw: w / 2, hd: d / 2, type: m.type });
+      shared2.inter.objs.push({ f: M.floor, cx: m.x, cz: m.z, c: Math.cos(M.ry), s: Math.sin(M.ry), hw: w / 2, hd: d / 2, type: m.type });
     }
     function objectDistance(o, x, z) {
       const dx = x - o.cx, dz = z - o.cz, lx = dx * o.c - dz * o.s, lz = dx * o.s + dz * o.c, ex = Math.abs(lx) - o.hw, ez = Math.abs(lz) - o.hd;
@@ -32763,7 +32868,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     }
     function collideObject(x, z, fx, fz, floor2) {
       const R = 0.2;
-      for (const o of shared.inter.objs) {
+      for (const o of shared2.inter.objs) {
         if (o.f !== -1 ? o.f !== floor2 : floor2 !== 0) continue;
         const d1 = objectDistance(o, x, z);
         if (d1 < R && d1 < objectDistance(o, fx, fz) - 1e-6) return true;
@@ -32773,7 +32878,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     function collideAt(x, z, floor2, opt) {
       opt = opt || {};
       const R = opt.radius != null ? opt.radius : 0.24;
-      for (const c of shared.ctx.colliders) {
+      for (const c of shared2.ctx.colliders) {
         if (c.off) continue;
         if (c.f !== -1 && c.f !== floor2) continue;
         if (c.f === -1 && floor2 !== 0) continue;
@@ -32785,7 +32890,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     }
     Object.assign(K, { NO_COLLIDE, registerCollision, objectDistance, collideObject, collideAt });
   }
-  function installInteractionItems(K, shared) {
+  function installInteractionItems(K, shared2) {
     const { t, LIGHTS, cursor, definePiece, localOf, registerCollision, togglePiece } = K;
     const DOOR_ITEM = /^(tv_unit|tv_unit_small|tv_unit_large|sideboard|china_cabinet|filing_cabinet|pantry|laundry_cabinet|wardrobe|wardrobe_small|wardrobe_large|closet_wardrobe|kitchen_cabinet|kitchen_cabinet_large|kitchen_cabinet_small|fridge|fridge_large|display_fridge_medium|display_fridge)$/;
     const DRAWER_ITEM = /^(console_table|dresser|nightstand|vanity_table)$/;
@@ -32810,7 +32915,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     }
     function lightItem(m, M, ent, api, parent) {
       M.on = M.light = M.lit = true;
-      const n0 = LIGHTS.length, name = shared.quality === "game" ? "ix:light:" + m.room + "@" + parent : "ix:light:" + m.id;
+      const n0 = LIGHTS.length, name = shared2.quality === "game" ? "ix:light:" + m.room + "@" + parent : "ix:light:" + m.id;
       cursor.group = name;
       try {
         ent.f(M, api);
@@ -32818,8 +32923,8 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         cursor.group = parent;
       }
       for (let i = n0; i < LIGHTS.length; i++) LIGHTS[i].roomId = m.room;
-      if (!shared.inter.defs.has(name)) definePiece(name, { kind: "light", pivot: [0, 0, 0], ry: 0, parent, roomId: m.room });
-      shared.inter.litRooms.add(m.room);
+      if (!shared2.inter.defs.has(name)) definePiece(name, { kind: "light", pivot: [0, 0, 0], ry: 0, parent, roomId: m.room });
+      shared2.inter.litRooms.add(m.room);
     }
     function curtainItem(m, M, ent, api, parent) {
       M.open = false;
@@ -32847,12 +32952,12 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       for (const c of body) api[c[0]](M, ...c[1]);
       if (!parts.length) return;
       const [ax, az] = localOf(M, 0, 0.2);
-      shared.inter.items.push({ type: "curtain", id: m.id, floor: M.floor, anchor: [ax, M.base + (M.y || 0) + (m.h || 2) * 0.5, az], range: 2.4, angle: 1, pieces: parts, text: () => t(parts[0].target > 0.5 ? "prompt.close" : "prompt.open", { what: t("what.curtain") }), action: () => {
+      shared2.inter.items.push({ type: "curtain", id: m.id, floor: M.floor, anchor: [ax, M.base + (M.y || 0) + (m.h || 2) * 0.5, az], range: 2.4, angle: 1, pieces: parts, text: () => t(parts[0].target > 0.5 ? "prompt.close" : "prompt.open", { what: t("what.curtain") }), action: () => {
         const al = parts[0].target > 0.5 ? 0 : 1;
         for (const p of parts) {
           p.target = al;
-          shared.partState.set(p.name, al);
-          shared.inter.anim.add(p);
+          shared2.partState.set(p.name, al);
+          shared2.inter.anim.add(p);
         }
       } });
     }
@@ -32922,8 +33027,8 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         p.def = def;
         parts.push(def);
         const [ax, az] = localOf(M, cx, front + 0.08);
-        shared.inter.items.push({ type: drawer ? "drawer" : "cabinet", id: m.id, floor: M.floor, anchor: [ax, M.base + (M.y || 0) + (p.y0 + p.y1) / 2, az], range: 1.6, angle: 0.4, pieces: [def], text: () => t(def.target > 0.5 ? "prompt.close" : "prompt.open", { what: t("what." + name) }), action: () => togglePiece(def) });
-        def.item = shared.inter.items[shared.inter.items.length - 1];
+        shared2.inter.items.push({ type: drawer ? "drawer" : "cabinet", id: m.id, floor: M.floor, anchor: [ax, M.base + (M.y || 0) + (p.y0 + p.y1) / 2, az], range: 1.6, angle: 0.4, pieces: [def], text: () => t(def.target > 0.5 ? "prompt.close" : "prompt.open", { what: t("what." + name) }), action: () => togglePiece(def) });
+        def.item = shared2.inter.items[shared2.inter.items.length - 1];
       });
       calls.forEach((c, i) => {
         const p = owner.get(i);
@@ -32939,10 +33044,10 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     }
     Object.assign(K, { DOOR_ITEM, DRAWER_ITEM, LIGHT_TYPES, objectName, recordApi, buildItem: buildItem2, lightItem, curtainItem, furnitureItem });
   }
-  function installInteractionFittings(K, shared) {
+  function installInteractionFittings(K, shared2) {
     const { t, EPS: EPS6, OPEN_AREA, Y0, applyPiece, bx, cursor, definePiece, gates, lightOn, roomAt, slideDirection, toggleLight, togglePiece } = K;
     function gatesInteractive() {
-      const lt2 = shared.ctx.r.lot;
+      const lt2 = shared2.ctx.r.lot;
       if (!lt2) return;
       const cz0 = (lt2.rect[1] + lt2.rect[3]) / 2;
       const orig = K.getBx(), gs = lt2.gates, opening = gs.map((g) => g.open), reg = gs.map((g) => {
@@ -32964,7 +33069,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         }
         return orig(mat, x0, y0, z0, x1, y1, z1, color2);
       });
-      const n0 = shared.ctx.colliders.length;
+      const n0 = shared2.ctx.colliders.length;
       try {
         gs.forEach((g) => {
           g.open = false;
@@ -32976,7 +33081,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
           g.open = opening[i];
         });
       }
-      const cols = shared.ctx.colliders.slice(n0), cz = (lt2.rect[1] + lt2.rect[3]) / 2, cu = (lt2.rect[0] + lt2.rect[2]) / 2;
+      const cols = shared2.ctx.colliders.slice(n0), cz = (lt2.rect[1] + lt2.rect[3]) / 2, cu = (lt2.rect[0] + lt2.rect[2]) / 2;
       reg.forEach((r, i) => {
         const g = r.g;
         if (!isFinite(r.x0)) return;
@@ -32985,25 +33090,25 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         const p = ped ? definePiece(name, Object.assign(base, { kind: "gate_swing", pivot: [r.x0, 0, g.v], angle: -sd * 1.65 })) : tilt ? definePiece(name, Object.assign(base, { kind: "gate_tilting", pivot: [(r.x0 + r.x1) / 2, r.y1, g.v], angle: -sd * 1.45 })) : definePiece(name, Object.assign(base, { kind: "gate_sliding", pivot: [r.x0, 0, r.zm], travel: r.dx * g.width }));
         if (p.col) p.col.off = p.target > 0.5;
         const text = () => t(p.target > 0.5 ? "prompt.close" : "prompt.open", { what: t(ped ? "what.pedestrianGate" : "what.garageGate") });
-        shared.inter.items.push({ type: "gate", id: g.id, floor: -1, anchor: [g.u, 1, g.v + sd * 0.4], range: 2.8, angle: 0.9, pieces: [p], text, action: () => togglePiece(p), noWall: true });
+        shared2.inter.items.push({ type: "gate", id: g.id, floor: -1, anchor: [g.u, 1, g.v + sd * 0.4], range: 2.8, angle: 0.9, pieces: [p], text, action: () => togglePiece(p), noWall: true });
       });
     }
     function mailboxInteractive() {
-      for (const m of shared.ctx.r.items) {
+      for (const m of shared2.ctx.r.items) {
         if (m.type !== "mailbox") continue;
-        const g = shared.ctx.parts && shared.ctx.parts["mailbox_" + m.id];
+        const g = shared2.ctx.parts && shared2.ctx.parts["mailbox_" + m.id];
         if (!g) continue;
         const name = "ix:correio:" + m.id, def = definePiece(name, { kind: "part", pivot: [0, 0, 0], ry: 0, parent: "lot" });
         def.inner = g;
         const fx = Math.sin(m.ry || 0), fz = Math.cos(m.ry || 0), ay = (m.y || 1) + (m.h || 0.3) * 0.4;
-        shared.inter.items.push({ type: "mailbox", id: m.id, floor: -1, anchor: [m.x + fx * 0.2, ay, m.z + fz * 0.2], range: 2.2, angle: 0.7, pieces: [def], text: () => t(def.target > 0.5 ? "prompt.close" : "prompt.open", { what: t("what.mailbox") }), action: () => togglePiece(def), noWall: true });
+        shared2.inter.items.push({ type: "mailbox", id: m.id, floor: -1, anchor: [m.x + fx * 0.2, ay, m.z + fz * 0.2], range: 2.2, angle: 0.7, pieces: [def], text: () => t(def.target > 0.5 ? "prompt.close" : "prompt.open", { what: t("what.mailbox") }), action: () => togglePiece(def), noWall: true });
         applyPiece(def);
       }
     }
     function placeSwitches() {
-      const R = shared.ctx.r, used = /* @__PURE__ */ new Set();
+      const R = shared2.ctx.r, used = /* @__PURE__ */ new Set();
       for (const c of R.rooms) {
-        if (c.type === "void" || OPEN_AREA(c) || !shared.inter.litRooms.has(c.id) || used.has(c.id) || shared.ctx.iv && shared.ctx.iv.switchRooms.has(c.id)) continue;
+        if (c.type === "void" || OPEN_AREA(c) || !shared2.inter.litRooms.has(c.id) || used.has(c.id) || shared2.ctx.iv && shared2.ctx.iv.switchRooms.has(c.id)) continue;
         const doors = R.doors.filter((p) => p.floor === c.floor && (p.a === c.id || p.b === c.id));
         doors.sort((p, q) => ((q.exterior ? 1 : 0) - (p.exterior ? 1 : 0)) * (c.type === "living" ? 1 : -1));
         for (const p of doors) if (putSwitch(c, p)) {
@@ -33013,7 +33118,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       }
     }
     function putSwitch(c, p) {
-      const R = shared.ctx.r, f = p.floor, alongU = p.axis === "u", L = p.pos, a = p.at - p.width / 2, b = p.at + p.width / 2;
+      const R = shared2.ctx.r, f = p.floor, alongU = p.axis === "u", L = p.pos, a = p.at - p.width / 2, b = p.at + p.width / 2;
       const wref = R.walls.find((w) => w.floor === f && w.axis === p.axis && Math.abs((alongU ? w.v0 : w.u0) - L) < EPS6), th = wref ? wref.thickness || 0.15 : 0.15;
       const inside2 = (sd2) => {
         const cc = roomAt(f, alongU ? p.at : L + sd2 * 0.4, alongU ? L + sd2 * 0.4 : p.at);
@@ -33040,17 +33145,17 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         const piece2 = definePiece("ix:int:" + roomId, { kind: "light_switch", pivot: pv, ry: 0, parent: "f" + f, axis: alongU ? "x" : "z", sgn: alongU ? sd : -sd, t0: lightOn(roomId) ? 1 : 0 });
         piece2.t = piece2.target = lightOn(roomId) ? 1 : 0;
         const an = alongU ? [u, yc, face + sd * 0.12] : [face + sd * 0.12, yc, u];
-        shared.inter.items.push({ type: "light_switch", id: roomId, floor: f, anchor: an, range: 1.5, angle: 0.45, pieces: [piece2], text: () => t(lightOn(roomId) ? "prompt.lightOff" : "prompt.lightOn"), action: () => toggleLight(roomId) });
+        shared2.inter.items.push({ type: "light_switch", id: roomId, floor: f, anchor: an, range: 1.5, angle: 0.45, pieces: [piece2], text: () => t(lightOn(roomId) ? "prompt.lightOff" : "prompt.lightOn"), action: () => toggleLight(roomId) });
         return true;
       }
       return false;
     }
     Object.assign(K, { gatesInteractive, mailboxInteractive, placeSwitches, putSwitch });
   }
-  function installInteractionDoors(K, shared) {
+  function installInteractionDoors(K, shared2) {
     const { t, colliderChanged, invalidateShadow, applyPiece, hudMessage } = K;
     function linkDoorLeaves() {
-      for (const fo of shared.ctx.leaves) fo.handles = (fo.handleNames || []).map((n) => shared.inter.defs.get(n)).filter(Boolean);
+      for (const fo of shared2.ctx.leaves) fo.handles = (fo.handleNames || []).map((n) => shared2.inter.defs.get(n)).filter(Boolean);
     }
     function handleApply(fo) {
       for (const mc of fo.handles || []) {
@@ -33062,7 +33167,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       if (fo.phase === "rattle") return;
       if (fo.phase === "handle" || fo.phase === "swing") {
         fo.open = !fo.open;
-        shared.doorState.set(fo.id, fo.open);
+        shared2.doorState.set(fo.id, fo.open);
         fo.col.off = fo.open;
         colliderChanged(fo.col);
         fo.anim = true;
@@ -33072,25 +33177,25 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       if (fo.blockedFlag || fo.locked) {
         fo.phase = "rattle";
         fo.jig = 0.7;
-        shared.ctx.animateDoorsOn = true;
+        shared2.ctx.animateDoorsOn = true;
         hudMessage(t(fo.blockedFlag ? "message.boarded" : "message.locked"));
         return;
       }
       fo.open = !fo.open;
-      shared.doorState.set(fo.id, fo.open);
+      shared2.doorState.set(fo.id, fo.open);
       fo.col.off = fo.open;
       colliderChanged(fo.col);
       fo.anim = true;
-      shared.ctx.animateDoorsOn = true;
+      shared2.ctx.animateDoorsOn = true;
       if (fo.handles && fo.handles.length) {
         fo.phase = "handle";
         fo.hT = fo.hT || 0;
       } else fo.phase = "swing";
     }
     function animateDoors(dt) {
-      if (!shared.ctx.animateDoorsOn) return;
+      if (!shared2.ctx.animateDoorsOn) return;
       let active = false;
-      for (const fo of shared.ctx.leaves) {
+      for (const fo of shared2.ctx.leaves) {
         if (!fo.phase) continue;
         active = true;
         if (fo.phase === "handle") {
@@ -33120,13 +33225,13 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
           }
         }
       }
-      shared.ctx.animateDoorsOn = active;
+      shared2.ctx.animateDoorsOn = active;
       invalidateShadow();
     }
     function wallBlocks(ex, ez, ax, az, floor2) {
-      const n = shared.ctx.wallColliders != null ? shared.ctx.wallColliders : 0;
+      const n = shared2.ctx.wallColliders != null ? shared2.ctx.wallColliders : 0;
       for (let i = 0; i < n; i++) {
-        const c = shared.ctx.colliders[i];
+        const c = shared2.ctx.colliders[i];
         if (c.f !== floor2 && !(c.f === -1 && floor2 === 0)) continue;
         let t0 = 0, t1 = 1;
         const dx = ax - ex, dz = az - ez;
@@ -33158,7 +33263,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     }
     Object.assign(K, { linkDoorLeaves, handleApply, toggleDoor, animateDoors, wallBlocks, doorText, applyLeaf });
   }
-  function installInteractionTarget(K, shared) {
+  function installInteractionTarget(K, shared2) {
     const { doorText, toggleDoor, visibleChain, wallBlocks } = K;
     const ivTarget = (...a) => K.ivTarget(...a);
     function targetOf(o, opt) {
@@ -33169,7 +33274,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       const tries = (score, text, action, target) => {
         if (!best || score < best.score) best = { score, text, action, target };
       };
-      for (const fo of shared.ctx.leaves) {
+      for (const fo of shared2.ctx.leaves) {
         if (fo.floor !== floor2) continue;
         const d = Math.hypot(fo.cx - ex, fo.cz - ez);
         if (d > 1.7) continue;
@@ -33177,11 +33282,11 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         if (angle > 1.35 && d > 0.9) continue;
         tries(angle * 1.6 + d * 0.5 + (angle < 0.25 ? 0 : 0.6), doorText(fo), () => toggleDoor(fo), fo);
       }
-      const vis = shared.inter.pieces.flatMap((p) => p.meshes).filter(visibleChain), hit = vis.length && opt.strike ? opt.strike(vis) : null;
-      const kitA = shared.ctx.iv ? ivTarget(shared.ctx.iv, o, opt && opt.interactives) : null;
+      const vis = shared2.inter.pieces.flatMap((p) => p.meshes).filter(visibleChain), hit = vis.length && opt.strike ? opt.strike(vis) : null;
+      const kitA = shared2.ctx.iv ? ivTarget(shared2.ctx.iv, o, opt && opt.interactives) : null;
       const nearKit = kitA && hit && Math.hypot(kitA.target.pos[0] - ex, kitA.target.pos[1] - ey, kitA.target.pos[2] - ez) < hit.distance + 0.1;
       const pieceHit = hit && !nearKit && hit.object.userData.piece;
-      for (const it of shared.inter.items) {
+      for (const it of shared2.inter.items) {
         if (it.floor !== floor2 && !(it.floor === -1 && floor2 === 0)) continue;
         const [ax, ay, az] = it.anchor, dx = ax - ex, dy = ay - ey, dz = az - ez, d = Math.hypot(dx, dy, dz), dh = Math.hypot(dx, dz);
         if (dh > it.range + 0.4) continue;
@@ -33196,14 +33301,14 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     }
     Object.assign(K, { targetOf });
   }
-  function installInteractablesBridge(K, shared) {
+  function installInteractablesBridge(K, shared2) {
     const { t, THREE, invalidate, invalidateShadow, cfg, DOC, LIGHT_TYPES, _Y, _q, _v3, accFor, applyLight, cursor, hashString, hudMessage, lightBase, pieceRecord, put, rgbOf, sh, wallBlocks } = K;
     const enter = (...a) => K.enter(...a);
     const roomLightMask = (...a) => K.roomLightMask(...a);
     const IV_MATERIAL = { plain: "plain", metal: "metal", wood: "wood", glass: "glass", fabric: "fabric", plant: "plant", water: "water", emissive: "emissive", atlas_picture: "picture", atlas_floor: "floor" };
     const IV_WIRE = { conduit: 13618628, cable: 2762532, drop: 1381653, cord: 1776413, earth: 3111482, hose: 11556124 };
     const IV_DOOR = /^(door|drawer)/;
-    const ivGroup = (e) => e.floor < 0 ? "lot" : "f" + Math.min(e.floor, shared.ctx.r.floors.length - 1);
+    const ivGroup = (e) => e.floor < 0 ? "lot" : "f" + Math.min(e.floor, shared2.ctx.r.floors.length - 1);
     function ivAccumulate(mat, g, ox, oy, oz, ry, color2) {
       const P = g.attributes.position, N = g.attributes.normal, C = color2 == null ? g.attributes.color : null, U = g.attributes.uv, I = g.index, nv = P.count, ni = I ? I.count : nv;
       const A = accFor(mat);
@@ -33247,7 +33352,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       A.ni += ni;
     }
     function ivBuild(h, water) {
-      const ik = K.IVK, r = shared.ctx.r, A = ik.A, world0 = null;
+      const ik = K.IVK, r = shared2.ctx.r, A = ik.A, world0 = null;
       void world0;
       const plane2 = A.plan(r, { seed: r.seed });
       const IV = { k: ik, plane: plane2, world: null, water, entries: /* @__PURE__ */ new Map(), roots: [], replace: /* @__PURE__ */ new Set(), roomStates: /* @__PURE__ */ new Map(), lampRoom: /* @__PURE__ */ new Map(), anim: /* @__PURE__ */ new Map(), screens: /* @__PURE__ */ new Map(), efx: null, items: null, itemsDirty: true, itemsT: 0, dirty: true, list: null, listT: 0, t: 0, circuits: [], switchRooms: /* @__PURE__ */ new Set(), warnings: [], tBuild: 0 };
@@ -33268,7 +33373,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       const wants = (roomId) => lightBase(roomId);
       const entById = new Map(plane2.items.map((e) => [e.id, e]));
       const entByItem = new Map(plane2.items.map((e) => [e.item, e]));
-      IV.mats = { plain: shared.mats.plain, metal: shared.mats.metal, wood: shared.mats.wood, glass: shared.mats.glass, fabric: shared.mats.fabric, plant: shared.mats.plant, water: shared.mats.water, emissive: shared.mats.emissive, atlas_picture: shared.mats.picture, atlas_floor: shared.mats.floor };
+      IV.mats = { plain: shared2.mats.plain, metal: shared2.mats.metal, wood: shared2.mats.wood, glass: shared2.mats.glass, fabric: shared2.mats.fabric, plant: shared2.mats.plant, water: shared2.mats.water, emissive: shared2.mats.emissive, atlas_picture: shared2.mats.picture, atlas_floor: shared2.mats.floor };
       const ev = (e) => ivEvent(h, e);
       const world = IV.world = A.createWorld(r, { water, seed: r.seed, onEvent: ev });
       const add0 = world.add;
@@ -33276,7 +33381,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         const e = entById.get(id);
         if (e && e.type === "lamp") {
           const roomId = IV.lampRoom.get(id);
-          spec.devices[0].on = roomId ? wants(roomId) : !!shared.ctx.night;
+          spec.devices[0].on = roomId ? wants(roomId) : !!shared2.ctx.night;
           spec.parts = (spec.parts || []).concat([{ id: "_x", pivot: [0, 0, 0], motion: { kind: "slide", axis: [0, 1, 0], distance: 1e-3 }, label: "" }]);
           spec.interactions = [{ id: "device.lamp", pos: [0, 0, 0], action: { do: "toggle_device", device: "lamp" }, label: "", requires: { object: id, part: "_x" } }];
         } else if (e && e.type === "wall_switch") {
@@ -33302,7 +33407,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
             }
             if (e.type === "lamp" && o.devices && o.devices.lamp) {
               const roomId = IV.lampRoom.get(id);
-              o.devices.lamp.on = roomId ? wants(roomId) : !!shared.ctx.night;
+              o.devices.lamp.on = roomId ? wants(roomId) : !!shared2.ctx.night;
             } else if (e.type === "wall_switch" && o.parts && o.parts.rocker !== void 0) {
               const l = (e.connections.controls || [])[0], roomId = l && IV.lampRoom.get(l);
               if (roomId) o.parts.rocker = wants(roomId) ? 1 : 0;
@@ -33394,7 +33499,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       const ik = IV.k, w = IV.world, wl = (o, p) => ik.GI.localToWorld(o.transform, p), g0 = cursor.group;
       const tube2 = (pts, radius, color2, ox, oy, oz, ry) => {
         try {
-          const m = ik.gfx.createCord(pts, radius, shared.mats.plain);
+          const m = ik.gfx.createCord(pts, radius, shared2.mats.plain);
           ivAccumulate("plain", m.geometry, ox, oy, oz, ry, color2);
           m.geometry.dispose();
         } catch (e) {
@@ -33437,7 +33542,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       for (const E of IV.roots) {
         (gs[E.group] || (gs[E.group] = new THREE.Group())).add(E.root);
       }
-      for (const [roomId] of IV.roomStates) if (!shared.inter.litRooms.has(roomId)) IV.roomStates.delete(roomId);
+      for (const [roomId] of IV.roomStates) if (!shared2.inter.litRooms.has(roomId)) IV.roomStates.delete(roomId);
       for (const E of IV.entries.values()) if (E.parts && Object.keys(E.parts).length) IV.k.gfx.syncObject(IV.world, E.id, E.parts, { time: 0 });
       for (const E of IV.entries.values()) if (E.screen) ivScreen(IV, E);
     }
@@ -33468,7 +33573,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
           break;
         case "device": {
           const roomId = IV.lampRoom.get(e.object);
-          if (roomId) shared.partState.set("light:" + roomId, !!e.on);
+          if (roomId) shared2.partState.set("light:" + roomId, !!e.on);
           invalidate();
           break;
         }
@@ -33621,7 +33726,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         gm.setIndex(new THREE.BufferAttribute(A.i.slice(0, A.ni), 1));
         gm.computeBoundingSphere();
         if (!IV.items) {
-          IV.items = new THREE.Mesh(gm, shared.mats.plain);
+          IV.items = new THREE.Mesh(gm, shared2.mats.plain);
           IV.items.name = "iv-items";
           IV.items.castShadow = false;
           IV.items.receiveShadow = true;
@@ -33762,17 +33867,17 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     }
     Object.assign(K, { IV_MATERIAL, IV_WIRE, IV_DOOR, ivGroup, ivAccumulate, ivBuild, ivRoomEffective, ivDraw, ivCords, ivAssemble, ivScreen, ivEvent, ivSeat, ivUpdate, IV_SHAPE, ivItems, ivTarget, ivRoomLight, ivParts, ivDispose, ivPublish });
   }
-  function installAnimationClotheslines(K, shared) {
+  function installAnimationClotheslines(K, shared2) {
     const { invalidate, CLOTHES_UNIFORMS } = K;
     const WIND = { t0: performance.now(), last: 0, base: 0.55 };
     function animateClotheslines(now) {
-      if (!shared.ctx.clotheslines || !shared.ctx.clotheslines.length) return;
+      if (!shared2.ctx.clotheslines || !shared2.ctx.clotheslines.length) return;
       if (now - WIND.last < 33) return;
       WIND.last = now;
       const t = (now - WIND.t0) / 1e3;
       CLOTHES_UNIFORMS.uTime.value = t;
       CLOTHES_UNIFORMS.uVento.value = WIND.base + 0.45 * Math.sin(t * 0.23) * Math.sin(t * 0.11 + 1.3) + 0.25 * Math.max(0, Math.sin(t * 0.57));
-      const g = shared.ctx.parts && shared.ctx.parts["laundry_" + shared.ctx.clotheslines[0]];
+      const g = shared2.ctx.parts && shared2.ctx.parts["laundry_" + shared2.ctx.clotheslines[0]];
       if (g) {
         let vis = true;
         for (let n = g; n; n = n.parent) if (!n.visible) {
@@ -33785,30 +33890,30 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     }
     Object.assign(K, { WIND, animateClotheslines });
   }
-  function installBuildInstance(K, shared) {
+  function installBuildInstance(K, shared2) {
     const { PROPS, THREE, DOC, cfg, HP, createInteractiveMaterials, createMaterials: createMaterials2, typeTable } = K;
     const props = PROPS.create(THREE, { document: DOC, emit: () => {
     } });
     const TYPES = typeTable(props);
-    shared.mats = createMaterials2(props);
-    createInteractiveMaterials(shared.mats);
+    shared2.mats = createMaterials2(props);
+    createInteractiveMaterials(shared2.mats);
     if (cfg.materials) for (const k of Object.keys(cfg.materials)) {
       const v = cfg.materials[k];
-      shared.mats[k] = typeof v === "function" ? v(shared.mats[k], k) || shared.mats[k] : v;
+      shared2.mats[k] = typeof v === "function" ? v(shared2.mats[k], k) || shared2.mats[k] : v;
     }
     const newState = () => ({ doors: /* @__PURE__ */ new Map(), inter: /* @__PURE__ */ new Map(), water: null, iv: null });
     function enter(h) {
-      shared.ctx = h.ctx;
-      shared.inter = h.inter;
-      shared.doorState = h.state.doors;
-      shared.partState = h.state.inter;
-      shared.mirrors = h.mirrors;
-      shared.quality = h.quality;
+      shared2.ctx = h.ctx;
+      shared2.inter = h.inter;
+      shared2.doorState = h.state.doors;
+      shared2.partState = h.state.inter;
+      shared2.mirrors = h.mirrors;
+      shared2.quality = h.quality;
     }
     const tagDamage = (type) => ({ type, hp: HP[type], hpMax: HP[type] });
     Object.assign(K, { props, TYPES, newState, enter, tagDamage });
   }
-  function installInteractablesKit(K, shared) {
+  function installInteractablesKit(K, shared2) {
     const { t, THREE, DOC, cfg, Reflector } = K;
     const roomLightMask = (...a) => K.roomLightMask(...a);
     const IVK = (() => {
@@ -33826,15 +33931,15 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       const l = cfg.vegetation || null, G = l && (l.GameVegetation || (l.buildLot ? l : null)), S = l && (l.GameVegetationSpecies || (l.toSpec ? l : null));
       return G && S && G.buildLot && S.toSpec ? { G, S } : null;
     })();
-    shared.vegMaterials = null;
-    const vegMaterials = () => shared.vegMaterials || (shared.vegMaterials = (() => {
+    shared2.vegMaterials = null;
+    const vegMaterials = () => shared2.vegMaterials || (shared2.vegMaterials = (() => {
       const m = VEG.G.createVegetationMaterials(THREE);
       for (const k of ["wood", "foliage", "flowers", "fruit", "spines"]) roomLightMask(m[k]);
       return m;
     })());
     Object.assign(K, { IVK, VEG, vegMaterials });
   }
-  function installLightsRoomLight(K, shared) {
+  function installLightsRoomLight(K, shared2) {
     const { THREE, rectsOf: rectsOf2 } = K;
     const MAX_LIGHTS = 12, EMPTY = [1e9, 1e9, -1e9, -1e9];
     const LZU = { uRB0: { value: new Float32Array(MAX_LIGHTS * 4) }, uRB1: { value: new Float32Array(MAX_LIGHTS * 4) }, uRB2: { value: new Float32Array(MAX_LIGHTS * 4) }, uRBY: { value: new Float32Array(MAX_LIGHTS * 2) }, uREx: { value: new Float32Array(MAX_LIGHTS * 4) }, uIndK: { value: 0.06 } };
@@ -33873,7 +33978,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     function lighting(o) {
       o = o || {};
       const scene = o.scene, N = Math.max(1, Math.min(MAX_LIGHTS, o.n || 6)), NS = Math.max(0, Math.min(N, o.shadows != null ? o.shadows : 2)), size = o.shadowSize || 512, MAX_EXTERNAL = o.external != null ? o.external : 2;
-      for (const k of Object.keys(shared.mats)) roomLightMask(shared.mats[k]);
+      for (const k of Object.keys(shared2.mats)) roomLightMask(shared2.mats[k]);
       const PL = [], sig = new Array(N).fill(""), seg2 = { n: 0 };
       for (let i = 0; i < N; i++) {
         const l = new THREE.PointLight(16763008, 0, 8, 1.6);
@@ -34066,9 +34171,9 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     }
     return view;
   }
-  function installDestructionPieces(K, shared) {
+  function installDestructionPieces(K, shared2) {
     const { THREE, floorAtY, pieceRecord } = K;
-    shared.destructionSeq = 0;
+    shared2.destructionSeq = 0;
     const FRAGMENT_COLOR = { brick: 11031866, concrete: 10132118, plaster: 14210248, ceramic: 11821630, glass: 11456472, tempered_glass: 11456472, wood_soft: 11569752, wood_hard: 8016948, plywood: 12098154, mdf: 12098154, steel: 9080466, aluminium: 12106944, plastic: 3107496, copper: 12088115, stone: 9079428, fabric: 13616296 };
     const FRAGMENT_GEO = new THREE.BoxGeometry(1, 1, 1), FRAGMENT_MAT = {};
     const fragmentMaterial = (m) => FRAGMENT_MAT[m] || (FRAGMENT_MAT[m] = new THREE.MeshLambertMaterial({ color: FRAGMENT_COLOR[m] != null ? FRAGMENT_COLOR[m] : 9079428 }));
@@ -34077,7 +34182,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         objs = objs.filter(Boolean);
         if (!objs.length) return;
         const pc = pieceRecord(id, mat, role, extra);
-        shared.ctx.pieceObjects.set(id, objs);
+        shared2.ctx.pieceObjects.set(id, objs);
         for (const o of objs) o.traverse((m) => {
           if (!m.isMesh) return;
           const u = m.userData;
@@ -34088,22 +34193,22 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
           if (pc.explodes) u.destructionExplodes = pc.explodes;
         });
       };
-      for (const fo of shared.ctx.leaves) {
+      for (const fo of shared2.ctx.leaves) {
         const pr = r.doors.find((p) => p.id === fo.id);
         tagObject("door:" + fo.id, fo.gs, fo.type === "steel" ? "steel" : pr && pr.exterior ? "wood_hard" : "mdf", null, { floor: fo.floor, mass: fo.type === "steel" ? 60 : 18, tags: ["door"] });
       }
       const cap = r.utilities.plumbing ? +r.utilities.plumbing.capacityL || 0 : 0;
-      for (const [id, g] of Object.entries(shared.ctx.parts || {})) {
+      for (const [id, g] of Object.entries(shared2.ctx.parts || {})) {
         const tp = g.userData.part;
         if (tp === "water_tank") {
-          const e = shared.ctx.structureIndex.water_tank, L = cap || (g.userData.volume ? Math.round(g.userData.volume * 1e3) : 0);
+          const e = shared2.ctx.structureIndex.water_tank, L = cap || (g.userData.volume ? Math.round(g.userData.volume * 1e3) : 0);
           tagObject("water_tank", [g], "plastic", e ? e.role : null, { floor: e ? e.floor : 0, contains: L ? { fluid: "water", liters: L } : void 0, mass: e ? e.mass : 25, thickness: 4e-3, fill: 0.05, tags: ["tank"] });
         } else if (tp === "gas_cylinder") tagObject(id, [g], "steel", null, { mass: 11, form: "cylinder", thickness: 3e-3, fill: 0.03, contains: { fluid: "gas", liters: 13, pressurized: true }, explodes: { energy: 12e4, radius: 5, atC: 300 }, tags: ["gas_bottle"] });
         else if (tp === "wall_pipe") tagObject(id, [g], "plastic", null, { mass: 3, tags: ["pipe"] });
         else if (tp === "shower_door") tagObject(id, [g], "tempered_glass", null, { mass: 25 });
         else if (tp === "gate_leaf" || tp === "mailbox_door") tagObject(id, [g], "steel", null, { mass: 30 });
       }
-      for (const def of shared.inter.defs.values()) {
+      for (const def of shared2.inter.defs.values()) {
         if (!def.outer) continue;
         if (/^gate/.test(def.kind)) tagObject(def.name, [def.outer], "steel", null, { mass: 80, tags: ["gate"] });
         else if (def.kind === "swing" || def.kind === "drawer") tagObject(def.name, [def.outer], "mdf", null, { mass: 6 });
@@ -34122,13 +34227,13 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
           for (const f of o.userData.ranges) add2(f.id, { mesh: o, v0: f.v0, v1: f.v1, i0: f.i0, i1: f.i1, whole: f.v0 === 0 && f.v1 === nv });
         }
       });
-      for (const [id, objs] of shared.ctx.pieceObjects) for (const o of objs) add2(id, { obj: o });
+      for (const [id, objs] of shared2.ctx.pieceObjects) for (const o of objs) add2(id, { obj: o });
       const box32 = (id) => {
         const b = new THREE.Box3(), v = new THREE.Vector3();
         for (const it of meshes.get(id) || []) {
           if (it.obj) {
             const bb = new THREE.Box3().setFromObject(it.obj);
-            if (!bb.isEmpty()) for (const x of [bb.min.x, bb.max.x]) for (const y of [bb.min.y, bb.max.y]) for (const z of [bb.min.z, bb.max.z]) b.expandByPoint(v.set(x, y, z).applyMatrix4(shared.ctx.unitInverse));
+            if (!bb.isEmpty()) for (const x of [bb.min.x, bb.max.x]) for (const y of [bb.min.y, bb.max.y]) for (const z of [bb.min.z, bb.max.z]) b.expandByPoint(v.set(x, y, z).applyMatrix4(shared2.ctx.unitInverse));
           } else {
             const P = it.mesh.geometry.attributes.position.array;
             for (let k = it.v0; k < it.v1; k++) b.expandByPoint(v.set(P[k * 3], P[k * 3 + 1], P[k * 3 + 2]));
@@ -34138,15 +34243,15 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       };
       const parts = [], byId = /* @__PURE__ */ new Map(), supports = E0.supports.map((a) => Object.assign({}, a));
       for (const e of E0.parts) {
-        const p = Object.assign({}, e, { meshes: (meshes.get(e.id) || []).length, extra: false }), pc = shared.ctx.pieces.get(e.id);
+        const p = Object.assign({}, e, { meshes: (meshes.get(e.id) || []).length, extra: false }), pc = shared2.ctx.pieces.get(e.id);
         if (pc) {
           for (const k of ["contains", "explodes", "tags", "form", "thickness", "fill"]) if (pc[k] != null && p[k] == null) p[k] = pc[k];
         }
         parts.push(p);
         byId.set(p.id, p);
       }
-      const base = parts.length, view = shared.ctx.panelView || panelViewOf(null, false), panelIds = new Set(view.panels.map((e) => e.id));
-      for (const [id, pc] of shared.ctx.pieces) {
+      const base = parts.length, view = shared2.ctx.panelView || panelViewOf(null, false), panelIds = new Set(view.panels.map((e) => e.id));
+      for (const [id, pc] of shared2.ctx.pieces) {
         if (byId.has(id) || panelIds.has(id) || !meshes.has(id)) continue;
         const b = box32(id);
         if (!b) continue;
@@ -34180,7 +34285,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         parts.splice(0, parts.length, ...parts.filter((p) => !gone.has(p.id)));
         for (const id of gone) byId.delete(id);
         for (const e of view.panels) {
-          const p = Object.assign({}, e, { meshes: (meshes.get(e.id) || []).length, extra: false }), pc = shared.ctx.pieces.get(e.id);
+          const p = Object.assign({}, e, { meshes: (meshes.get(e.id) || []).length, extra: false }), pc = shared2.ctx.pieces.get(e.id);
           if (pc) {
             for (const k of ["contains", "explodes", "tags", "form", "thickness", "fill"]) if (pc[k] != null && p[k] == null) p[k] = pc[k];
           }
@@ -34287,6 +34392,12 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
   var SPALL_RAGGED = 0.045;
   var COVER2 = 0.015;
   var MAX_FLAKES = 64;
+  function clipToBox(unit, box5) {
+    const lo = [Math.max(unit.x - unit.sx / 2, box5[0]), Math.max(unit.y - unit.sy / 2, box5[1]), Math.max(unit.z - unit.sz / 2, box5[2])];
+    const hi = [Math.min(unit.x + unit.sx / 2, box5[3]), Math.min(unit.y + unit.sy / 2, box5[4]), Math.min(unit.z + unit.sz / 2, box5[5])];
+    if (hi[0] - lo[0] <= 1e-4 || hi[1] - lo[1] <= 1e-4 || hi[2] - lo[2] <= 1e-4) return null;
+    return { x: (lo[0] + hi[0]) / 2, y: (lo[1] + hi[1]) / 2, z: (lo[2] + hi[2]) / 2, sx: hi[0] - lo[0], sy: hi[1] - lo[1], sz: hi[2] - lo[2], colour: unit.colour };
+  }
   function installDestructionBreach(K, _shared) {
     const { THREE, fragmentMaterial, invalidate, invalidateShadow } = K;
     function createBreachView(opts) {
@@ -34397,6 +34508,16 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         material.userData.breachCore = core;
         return material;
       }
+      function drawnBounds(items) {
+        house.updateMatrixWorld(true);
+        const box5 = new THREE.Box3(), toHouse = new THREE.Matrix4().copy(house.matrixWorld).invert();
+        for (const it of items) {
+          const a = it.mesh.userData._p0 || it.mesh.geometry.attributes.position.array;
+          tmp.m.multiplyMatrices(toHouse, it.mesh.matrixWorld);
+          for (let k = it.v0; k < it.v1; k++) box5.expandByPoint(tmp.p.set(a[k * 3], a[k * 3 + 1], a[k * 3 + 2]).applyMatrix4(tmp.m));
+        }
+        return [box5.min.x, box5.min.y, box5.min.z, box5.max.x, box5.max.y, box5.max.z];
+      }
       function maskOf(hostId, parts) {
         const host = structure.byId.get(hostId);
         const [u0, v0, u1, v1] = host.aabb;
@@ -34484,7 +34605,10 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         for (const { c, part, units: units2, thick, mid } of shown) {
           if (!near(c)) continue;
           const centre = mask.start + (c.a + c.b) / 2, y = (c.y0 + c.y1) / 2, len = c.b - c.a, h = c.y1 - c.y0;
-          const at3 = (s, dy, d, colour) => list2.push({ x: mask.alongU ? centre : mid, y, z: mask.alongU ? mid : centre, sx: mask.alongU ? s : d, sy: dy, sz: mask.alongU ? d : s, colour });
+          const at3 = (s, dy, d, colour) => {
+            const unit = clipToBox({ x: mask.alongU ? centre : mid, y, z: mask.alongU ? mid : centre, sx: mask.alongU ? s : d, sy: dy, sz: mask.alongU ? d : s, colour }, view.bounds);
+            if (unit) list2.push(unit);
+          };
           const base = fragmentMaterial(part.material).color.getHex();
           const n = noise2(centre * 3.1, y * 2.7, 0.07);
           if (units2.mortar === "concrete") {
@@ -34551,6 +34675,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
             units: null,
             gone: 0,
             pits: 0,
+            bounds: drawnBounds(items),
             chips: new Map(parts.map((id) => [id, []])),
             spalls: new Map(parts.map((id) => [id, []])),
             openings: /* @__PURE__ */ new Map(),
@@ -34704,7 +34829,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     Object.assign(K, { createBreachView });
   }
   var FOLLOW_FLUSH_FALLBACK_MS = 100;
-  function installDestructionWorld(K, shared) {
+  function installDestructionWorld(K, shared2) {
     const { THREE, cfg, invalidateShadow, invalidate, rngString, FRAGMENT_GEO, fragmentMaterial, createBreachView } = K;
     function createHouseDestruction(root, house, structure, parts, colliders, water) {
       const D = { world: cfg.destruction || null, id: null, active: false }, hiddenPieces = /* @__PURE__ */ new Set(), bodies = /* @__PURE__ */ new Map(), frags = [], facets = /* @__PURE__ */ new Map();
@@ -34940,7 +35065,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         house.matrixWorld.decompose(p, q, sc);
         D.specOptions = specOptions || null;
         D.spec = structure.spec(specOptions);
-        D.id = D.world.add(D.spec, { id: "house3d:" + ++shared.destructionSeq, position: [p.x, p.y, p.z], rotation: [q.x, q.y, q.z, q.w] });
+        D.id = D.world.add(D.spec, { id: "house3d:" + ++shared2.destructionSeq, position: [p.x, p.y, p.z], rotation: [q.x, q.y, q.z, q.w] });
         breach.claim();
         if (R) R.bind(D.id, house, { parts: rangesOf(), onFrame: () => breach.flush() });
         off = D.world.on("*", handleEvent);
@@ -35086,7 +35211,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     }
     Object.assign(K, { createHouseDestruction });
   }
-  function installBuildBuild(K, shared) {
+  function installBuildBuild(K, shared2) {
     const { THREE, cfg, rectsOf: rectsOf2, invalidateShadow, colliderChanged, VERSION: VERSION2, CARS, EPS: EPS6, LIGHTS, MIRRORS, Y0, animateClotheslines, animateDoors, animateInteractive, applyLeaf, applyOutbuildings, applyPart, applyPiece, assembleInteractive, baseboardAndSidewalk, buildStairs, building, carModel, chooseMirror, closeScene, collideAt, createWater, cursor, doorText, doors, electricalStructure, elevator, floorsAndSlabs, gatesInteractive, houseItems, ivAssemble, ivBuild, ivDispose, ivParts, ivPublish, ivUpdate, lightOn, linkDoorLeaves, mailboxInteractive, newInteractiveState, newMirrorState, outbuildings, paths, perimeter, placeSwitches, roofs, roomAt, solar, targetOf, terrain, toggleDoor, toggleLight, walls, waterPipes, windows, props, TYPES, IVK, VEG, vegMaterials, markGroups, assembleStructure, createHouseDestruction, newState, enter, tagDamage } = K;
     function build(r0, opts) {
       opts = opts || {};
@@ -35097,43 +35222,43 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       cursor.accs.clear();
       LIGHTS.length = 0;
       const pr = opts.building || {};
-      shared.ctx.r = r;
-      shared.ctx.colors = r.colors;
-      shared.ctx.cut = !!opts.cut;
-      shared.ctx.night = !!opts.night;
-      shared.ctx.labels = [];
-      shared.ctx.colliders = [];
-      shared.ctx.stairs = [];
-      shared.ctx.noTerrain = opts.terrain === false;
-      shared.ctx.roomById = {};
-      for (const c of r.rooms) shared.ctx.roomById[c.id] = c;
-      shared.ctx.pieces = /* @__PURE__ */ new Map();
-      shared.ctx.pieceObjects = /* @__PURE__ */ new Map();
-      shared.ctx.structureIndex = {};
-      for (const e of r0.structure && r0.structure.parts || []) shared.ctx.structureIndex[e.id] = e;
+      shared2.ctx.r = r;
+      shared2.ctx.colors = r.colors;
+      shared2.ctx.cut = !!opts.cut;
+      shared2.ctx.night = !!opts.night;
+      shared2.ctx.labels = [];
+      shared2.ctx.colliders = [];
+      shared2.ctx.stairs = [];
+      shared2.ctx.noTerrain = opts.terrain === false;
+      shared2.ctx.roomById = {};
+      for (const c of r.rooms) shared2.ctx.roomById[c.id] = c;
+      shared2.ctx.pieces = /* @__PURE__ */ new Map();
+      shared2.ctx.pieceObjects = /* @__PURE__ */ new Map();
+      shared2.ctx.structureIndex = {};
+      for (const e of r0.structure && r0.structure.parts || []) shared2.ctx.structureIndex[e.id] = e;
       {
-        const view = shared.ctx.panelView = panelViewOf(r0.structure, !!cfg.destruction);
-        shared.ctx.panelsOf = /* @__PURE__ */ new Map();
-        for (const id of view.replaced) delete shared.ctx.structureIndex[id];
+        const view = shared2.ctx.panelView = panelViewOf(r0.structure, !!cfg.destruction);
+        shared2.ctx.panelsOf = /* @__PURE__ */ new Map();
+        for (const id of view.replaced) delete shared2.ctx.structureIndex[id];
         for (const e of view.panels) {
-          shared.ctx.structureIndex[e.id] = e;
-          const l = shared.ctx.panelsOf.get(e.slab);
+          shared2.ctx.structureIndex[e.id] = e;
+          const l = shared2.ctx.panelsOf.get(e.slab);
           if (l) l.push(e);
-          else shared.ctx.panelsOf.set(e.slab, [e]);
+          else shared2.ctx.panelsOf.set(e.slab, [e]);
         }
       }
-      shared.ctx.panes = r0.roof && r0.roof.panes || [];
-      shared.ctx.noPiece = false;
+      shared2.ctx.panes = r0.roof && r0.roof.panes || [];
+      shared2.ctx.noPiece = false;
       cursor.separate = opts.pieces === "meshes";
       cursor.pc = null;
-      shared.ctx.apartment = r.template === "apartment_modern";
-      shared.ctx.pa = Math.max(3, Math.min(20, pr.floors != null ? pr.floors : 5));
-      shared.ctx.pf = Math.max(1, Math.min(shared.ctx.pa, pr.floor != null ? pr.floor : 3));
-      shared.ctx.pu = Math.max(0, pr.unit != null ? pr.unit : 0);
-      shared.ctx.showBuilding = shared.ctx.apartment && (pr.showIt == null ? true : !!pr.showIt);
-      shared.ctx.limits = { x0: -2, z0: -2, x1: r.w + 2, z1: r.d + 2 };
-      shared.ctx.veg = VEG ? { G: VEG.G, S: VEG.S, mats: vegMaterials, groups: /* @__PURE__ */ new Map(), ok: /* @__PURE__ */ new Map(), opts: shared.quality === "game" ? { quality: "game" } : { lod: 0, triangleBudget: 6e4 } } : null;
-      shared.ctx.vegInfo = null;
+      shared2.ctx.apartment = r.template === "apartment_modern";
+      shared2.ctx.pa = Math.max(3, Math.min(20, pr.floors != null ? pr.floors : 5));
+      shared2.ctx.pf = Math.max(1, Math.min(shared2.ctx.pa, pr.floor != null ? pr.floor : 3));
+      shared2.ctx.pu = Math.max(0, pr.unit != null ? pr.unit : 0);
+      shared2.ctx.showBuilding = shared2.ctx.apartment && (pr.showIt == null ? true : !!pr.showIt);
+      shared2.ctx.limits = { x0: -2, z0: -2, x1: r.w + 2, z1: r.d + 2 };
+      shared2.ctx.veg = VEG ? { G: VEG.G, S: VEG.S, mats: vegMaterials, groups: /* @__PURE__ */ new Map(), ok: /* @__PURE__ */ new Map(), opts: shared2.quality === "game" ? { quality: "game" } : { lod: 0, triangleBudget: 6e4 } } : null;
+      shared2.ctx.vegInfo = null;
       terrain();
       if (r.lot) {
         if (!opts.noPerimeter) {
@@ -35144,7 +35269,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       }
       walls();
       baseboardAndSidewalk();
-      shared.ctx.wallColliders = shared.ctx.colliders.length;
+      shared2.ctx.wallColliders = shared2.ctx.colliders.length;
       doors();
       windows();
       floorsAndSlabs();
@@ -35152,14 +35277,14 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       buildStairs();
       elevator();
       const water = createWater(r, h.state);
-      shared.ctx.iv = null;
+      shared2.ctx.iv = null;
       h.IV = null;
       if (IVK) {
         try {
-          h.IV = shared.ctx.iv = ivBuild(h, water);
+          h.IV = shared2.ctx.iv = ivBuild(h, water);
         } catch (e) {
           console.warn("interactables", e);
-          shared.ctx.iv = h.IV = null;
+          shared2.ctx.iv = h.IV = null;
         }
       }
       const noModel = houseItems();
@@ -35168,14 +35293,14 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       electricalStructure();
       roofs();
       solar();
-      if (shared.ctx.showBuilding) building();
+      if (shared2.ctx.showBuilding) building();
       for (const c of r.rooms) {
         if (c.type === "void") continue;
         const [a, b, c2, d] = rectsOf2(c)[0];
-        shared.ctx.labels.push({ pos: new THREE.Vector3((a + c2) / 2, Y0(c.floor) + 1.1, (b + d) / 2), text: c.name, group: "f" + c.floor, type: "room", floor: c.floor });
+        shared2.ctx.labels.push({ pos: new THREE.Vector3((a + c2) / 2, Y0(c.floor) + 1.1, (b + d) / 2), text: c.name, group: "f" + c.floor, type: "room", floor: c.floor });
       }
-      const mirrorsCopy = MIRRORS.map((E, i) => Object.assign({ i }, E)), gs = closeScene(shared.mats);
-      for (const fo of shared.ctx.leaves) {
+      const mirrorsCopy = MIRRORS.map((E, i) => Object.assign({ i }, E)), gs = closeScene(shared2.mats);
+      for (const fo of shared2.ctx.leaves) {
         const parent = gs["f" + fo.floor] || (gs["f" + fo.floor] = new THREE.Group());
         fo.gs = [];
         for (const gd of fo.groups) {
@@ -35188,22 +35313,22 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         }
         applyLeaf(fo);
       }
-      if (shared.ctx.iv) ivAssemble(shared.ctx.iv, gs);
+      if (shared2.ctx.iv) ivAssemble(shared2.ctx.iv, gs);
       assembleInteractive(gs);
       linkDoorLeaves();
       mailboxInteractive();
       const root = markKitOrigin(new THREE.Group(), { owner: "game-floorplan-three", kind: "structure", id: r.template }), house = new THREE.Group();
       root.name = "house3d";
       root.add(house);
-      shared.mirrors.house = house;
-      if (shared.ctx.apartment) {
-        const u = r.building.units[Math.min(shared.ctx.pu, r.building.units.length - 1)];
-        house.position.set(u.u, shared.ctx.showBuilding ? 0 : -r.floors[0].y0, u.v);
+      shared2.mirrors.house = house;
+      if (shared2.ctx.apartment) {
+        const u = r.building.units[Math.min(shared2.ctx.pu, r.building.units.length - 1)];
+        house.position.set(u.u, shared2.ctx.showBuilding ? 0 : -r.floors[0].y0, u.v);
         house.rotation.y = u.ry;
-        shared.ctx.unitRy = u.ry;
+        shared2.ctx.unitRy = u.ry;
       }
       house.updateMatrixWorld(true);
-      shared.ctx.unitInverse = house.matrixWorld.clone().invert();
+      shared2.ctx.unitInverse = house.matrixWorld.clone().invert();
       for (const [k, g] of Object.entries(gs)) {
         g.name = k;
         (k === "floor" || k === "building" ? root : house).add(g);
@@ -35212,31 +35337,31 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       h.root = root;
       h.house = house;
       h.houseGroup = house;
-      shared.ctx.noModel = noModel;
-      shared.ctx.lights = LIGHTS.filter((l) => l.type !== "lantern" && l.type !== "candles" || shared.ctx.night).map((l) => ({ ...l }));
-      shared.ctx.animateDoorsOn = shared.ctx.animateDoorsOn || false;
-      for (const c of shared.ctx.colliders) {
+      shared2.ctx.noModel = noModel;
+      shared2.ctx.lights = LIGHTS.filter((l) => l.type !== "lantern" && l.type !== "candles" || shared2.ctx.night).map((l) => ({ ...l }));
+      shared2.ctx.animateDoorsOn = shared2.ctx.animateDoorsOn || false;
+      for (const c of shared2.ctx.colliders) {
         c.aabb = [c.x0, c.z0, c.x1, c.z1];
         if (c.type === "wall") c.damageable = tagDamage("masonry");
       }
-      const colliders = shared.ctx.colliders.concat(shared.inter.objs.map((o) => ({ type: "furniture", f: o.f, obb: { cx: o.cx, cz: o.cz, hw: o.hw, hd: o.hd, c: o.c, s: o.s }, item: o.type, off: false })));
+      const colliders = shared2.ctx.colliders.concat(shared2.inter.objs.map((o) => ({ type: "furniture", f: o.f, obb: { cx: o.cx, cz: o.cz, hw: o.hw, hd: o.hd, c: o.c, s: o.s }, item: o.type, off: false })));
       const parts = {}, setOpen = (def, t) => {
         def.target = t;
         def.t = t;
-        shared.partState.set(def.name, t);
+        shared2.partState.set(def.name, t);
         if (def.col) {
           def.col.off = t > 0.5;
           colliderChanged(def.col);
         }
         applyPiece(def);
-        shared.inter.anim.delete(def);
+        shared2.inter.anim.delete(def);
         invalidateShadow();
       };
       const mark = (o, id) => {
         if (o) o.userData.partId = id;
       };
       const PART_DAMAGE = { water_tank: "water", shower_door: "glass", gate_leaf: "metal", mailbox_door: "metal", mirror: "glass", cooking_gas_cylinder: "gas" };
-      for (const [id, g] of Object.entries(shared.ctx.parts || {})) {
+      for (const [id, g] of Object.entries(shared2.ctx.parts || {})) {
         const tp = g.userData.part, dn = PART_DAMAGE[tp];
         if (dn) g.userData.damageable = tagDamage(dn);
         mark(g, id);
@@ -35256,7 +35381,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
           return g.userData.t || 0;
         }, meta: g.userData };
       }
-      for (const fo of shared.ctx.leaves) {
+      for (const fo of shared2.ctx.leaves) {
         const id = "door:" + fo.id, dn = tagDamage(fo.type === "steel" ? "metal" : "wood");
         fo.damageable = dn;
         for (const g of fo.gs) mark(g, id);
@@ -35268,14 +35393,14 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
             fo.col.off = fo.open;
             colliderChanged(fo.col);
           }
-          shared.doorState.set(fo.id, fo.open);
+          shared2.doorState.set(fo.id, fo.open);
           applyLeaf(fo);
           invalidateShadow();
         }, get t() {
           return fo.t;
         }, leaf: fo };
       }
-      for (const def of shared.inter.defs.values()) {
+      for (const def of shared2.inter.defs.values()) {
         if (!def.outer) continue;
         const cab = def.kind === "swing" || def.kind === "drawer", gate = /^gate/.test(def.kind);
         const dn = cab ? tagDamage("wood") : gate ? tagDamage("metal") : null;
@@ -35285,7 +35410,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
           return def.t;
         }, def };
       }
-      if (shared.ctx.iv) ivParts(shared.ctx.iv, parts, tagDamage);
+      if (shared2.ctx.iv) ivParts(shared2.ctx.iv, parts, tagDamage);
       const cars = [];
       CARS.forEach((C, i) => {
         const mod2 = carModel(C.k, C.seed);
@@ -35325,18 +35450,18 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       const actOn = (e, a) => {
         enter(h);
         if (cfg.onInteract && cfg.onInteract(e, a) === false) return false;
-        shared.inter.target = a || { target: e.ref, text: e.label, action: e._action };
+        shared2.inter.target = a || { target: e.ref, text: e.label, action: e._action };
         e._action();
         return true;
       };
-      for (const fo of shared.ctx.leaves) {
+      for (const fo of shared2.ctx.leaves) {
         const e = { id: "door:" + fo.id, type: fo.type === "steel" ? "garage_door" : "door", floor: fo.floor, pos: [fo.cx, Y0(fo.floor) + 1, fo.cz], radius: 1.7, get label() {
           return doorText(fo);
         }, ref: fo, _action: () => toggleDoor(fo) };
         e.act = () => actOn(e);
         interactables.push(e);
       }
-      for (const it of shared.inter.items) {
+      for (const it of shared2.inter.items) {
         const k = it.type + ":" + it.id, n = usedMap.get(k) || 0;
         usedMap.set(k, n + 1);
         const e = { id: n ? k + "#" + n : k, type: it.type, floor: it.floor, pos: it.anchor.slice(), radius: it.range, angle: it.angle, get label() {
@@ -35346,12 +35471,12 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         interactables.push(e);
         it.pub = e;
       }
-      for (const fo of shared.ctx.leaves) fo.pub = interactables.find((e) => e.ref === fo);
+      for (const fo of shared2.ctx.leaves) fo.pub = interactables.find((e) => e.ref === fo);
       const lodObjects = [];
-      for (const def of shared.inter.defs.values()) if (def.outer && /^(light|drawer|swing|curtain|light_switch|handle)$/.test(def.kind)) lodObjects.push(def.outer);
-      for (const [id, g] of Object.entries(shared.ctx.parts || {})) if (/^(handle|shower_door)$/.test(g.userData.part) && g.visible !== false) lodObjects.push(g);
-      if (shared.ctx.iv) {
-        for (const E of shared.ctx.iv.roots) lodObjects.push(E.root);
+      for (const def of shared2.inter.defs.values()) if (def.outer && /^(light|drawer|swing|curtain|light_switch|handle)$/.test(def.kind)) lodObjects.push(def.outer);
+      for (const [id, g] of Object.entries(shared2.ctx.parts || {})) if (/^(handle|shower_door)$/.test(g.userData.part) && g.visible !== false) lodObjects.push(g);
+      if (shared2.ctx.iv) {
+        for (const E of shared2.ctx.iv.roots) lodObjects.push(E.root);
       }
       const countDraw = () => {
         let n = 0, t = 0;
@@ -35369,7 +35494,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       for (const o of lodObjects) o.visible = true;
       const budget = opts.drawCallBudget != null ? opts.drawCallBudget : cfg.drawCallBudget;
       const stats2 = { quality: h.quality, drawCalls: s0.n, drawCallsLOD1: s1.n, triangles: s0.t, trianglesLod1: s1.t, budget: budget || null, overBudget: !!budget && s0.n > budget, tBuild: performance.now() - t0 };
-      shared.ctx.tBuild = stats2.tBuild;
+      shared2.ctx.tBuild = stats2.tBuild;
       const applyLod = (n) => {
         n = Math.max(0, Math.min(2, n | 0));
         if (n === h.lodCurrent) return;
@@ -35435,39 +35560,39 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         building: gs.building || null,
         waterTank: r.waterTank ? (() => {
           const pt = Object.values(parts).find((p) => p.type === "water_tank") || null;
-          return { part: pt, group: pt ? pt.group : null, pos: shared.ctx.waterTankPos || null, plant: r.waterTank };
+          return { part: pt, group: pt ? pt.group : null, pos: shared2.ctx.waterTankPos || null, plant: r.waterTank };
         })() : null,
         colliders,
         parts,
         cars,
         interactables,
-        doors: shared.ctx.leaves,
-        stairs: shared.ctx.stairs,
-        labels: shared.ctx.labels,
+        doors: shared2.ctx.leaves,
+        stairs: shared2.ctx.stairs,
+        labels: shared2.ctx.labels,
         noModel,
         lights: (() => {
           const by = {};
-          for (const l of shared.ctx.lights) {
+          for (const l of shared2.ctx.lights) {
             const k = l.roomId != null ? l.roomId : l.room;
             (by[k] || (by[k] = [])).push(l);
           }
-          return { list: shared.ctx.lights, byRoom: by };
+          return { list: shared2.ctx.lights, byRoom: by };
         })(),
-        limits: shared.ctx.limits,
-        apartment: shared.ctx.apartment,
-        showBuilding: shared.ctx.showBuilding,
-        buildingConfig: { floors: shared.ctx.pa, floor: shared.ctx.pf, unit: shared.ctx.pu },
-        unitRy: shared.ctx.unitRy || 0,
-        night: shared.ctx.night,
-        cut: shared.ctx.cut,
+        limits: shared2.ctx.limits,
+        apartment: shared2.ctx.apartment,
+        showBuilding: shared2.ctx.showBuilding,
+        buildingConfig: { floors: shared2.ctx.pa, floor: shared2.ctx.pf, unit: shared2.ctx.pu },
+        unitRy: shared2.ctx.unitRy || 0,
+        night: shared2.ctx.night,
+        cut: shared2.ctx.cut,
         interactives: h.IV ? ivPublish(h) : null,
         state: h.state,
         stats: stats2,
-        vegetation: shared.ctx.vegInfo || null,
-        solar: shared.ctx.solarInfo || null,
+        vegetation: shared2.ctx.vegInfo || null,
+        solar: shared2.ctx.solarInfo || null,
         water,
-        electrical: shared.ctx.electricalInfo || null,
-        gutters: shared.ctx.gutterInfo || null,
+        electrical: shared2.ctx.electricalInfo || null,
+        gutters: shared2.ctx.gutterInfo || null,
         // per frame: doors, parts, wind-blown laundry and (with a focus) distance LOD; dt in seconds, time in ms (rAF); focus = {x,y,z} in world coordinates
         update(dt, time, focus) {
           enter(h);
@@ -35477,9 +35602,9 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
           if (destruction.active || destruction.statistics().falling || destruction.statistics().fragments) destruction.animate(dt);
           if (h.IV) ivUpdate(h, dt, time, focus);
           if (time != null) animateClotheslines(time);
-          if (shared.vegMaterials) {
-            shared.vegMaterials.update((time != null ? time : performance.now()) / 1e3);
-            shared.vegMaterials.setActors(focus ? [{ x: focus.x, y: focus.y, z: focus.z, radius: 0.9 }] : []);
+          if (shared2.vegMaterials) {
+            shared2.vegMaterials.update((time != null ? time : performance.now()) / 1e3);
+            shared2.vegMaterials.setActors(focus ? [{ x: focus.x, y: focus.y, z: focus.z, radius: 0.9 }] : []);
           }
           if (focus && cfg.lod !== false) {
             const L = Object.assign({ interior: 45, hide: 220 }, cfg.lod), d = distance3(focus), at3 = h.lodCurrent;
@@ -35491,12 +35616,12 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         show(o) {
           enter(h);
           o = o || {};
-          const rr = shared.ctx.r, nA = rr.floors.length, a = o.floor == null ? -1 : o.floor, sel = a >= nA ? -1 : a, cut = !!o.cut;
+          const rr = shared2.ctx.r, nA = rr.floors.length, a = o.floor == null ? -1 : o.floor, sel = a >= nA ? -1 : a, cut = !!o.cut;
           for (const [k, g] of Object.entries(gs)) {
             let v = true;
             if (k[0] === "f") v = sel < 0 || +k.slice(1) <= sel;
             else if (k[0] === "t") v = !cut && (sel < 0 || +k.slice(1) < sel);
-            else if (k === "roof") v = !cut && sel < 0 && (!shared.ctx.apartment || !shared.ctx.showBuilding || shared.ctx.pf === shared.ctx.pa);
+            else if (k === "roof") v = !cut && sel < 0 && (!shared2.ctx.apartment || !shared2.ctx.showBuilding || shared2.ctx.pf === shared2.ctx.pa);
             else if (k === "attic_tank") v = (cut || sel >= 0) && (sel < 0 || nA - 1 <= sel);
             else if (k === "lot") v = o.lot == null ? true : !!o.lot;
             g.visible = v;
@@ -35513,11 +35638,11 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
           return actOn(a.target && a.target.pub ? a.target.pub : { id: a.target && a.target.id || a.text, type: a.target && a.target.kit ? a.target.type : "door", label: a.text, ref: a.target, _action: a.action }, a);
         },
         message() {
-          return shared.inter.msg && performance.now() < shared.inter.msg.until ? shared.inter.msg.text : null;
+          return shared2.inter.msg && performance.now() < shared2.inter.msg.until ? shared2.inter.msg.text : null;
         },
         toggleDoor(fo) {
           enter(h);
-          toggleDoor(typeof fo === "string" ? shared.ctx.leaves.find((f) => f.id === fo) : fo);
+          toggleDoor(typeof fo === "string" ? shared2.ctx.leaves.find((f) => f.id === fo) : fo);
         },
         lightOn(roomId) {
           enter(h);
@@ -35589,13 +35714,13 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
           });
           root.removeFromParent();
         },
-        internal: { h, ctx: shared.ctx, inter: shared.inter, partState: shared.partState, doorState: shared.doorState, mirrors: shared.mirrors }
+        internal: { h, ctx: shared2.ctx, inter: shared2.inter, partState: shared2.partState, doorState: shared2.doorState, mirrors: shared2.mirrors }
       };
       return res;
     }
     Object.assign(K, { build });
   }
-  function buildApi(K, shared) {
+  function buildApi(K, shared2) {
     const { cfg, VERSION: VERSION2, ATLAS, TEX, applyPart, carGroup, carModel, props, TYPES, roomLightMask, lighting, newState, build } = K;
     return {
       version: VERSION2,
@@ -35605,26 +35730,26 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       mv: props,
       applyPart,
       // the kernel and the shared state, for recorders that run the team's builders into something else than the house (`furnitureSpec`, `tapSpec`): not a stable api
-      internals: { K, shared },
+      internals: { K, shared: shared2 },
       get materials() {
-        return shared.mats;
+        return shared2.mats;
       },
       roomLightMask,
       lighting,
       setNight(n) {
-        shared.mats.glass.emissive.set(n ? 9067040 : 0);
-        shared.mats.glass.opacity = n ? 0.4 : 0.24;
+        shared2.mats.glass.emissive.set(n ? 9067040 : 0);
+        shared2.mats.glass.opacity = n ? 0.4 : 0.24;
       },
       cars: { model: carModel, group: carGroup, info: (k, seed) => {
         const m = carModel(k, seed);
         return m && { parts: m.parts.length, tris: m.tris, L: m.L, W: m.W, H: m.H };
       } },
       dispose() {
-        if (shared.vegMaterials) {
-          shared.vegMaterials.dispose();
-          shared.vegMaterials = null;
+        if (shared2.vegMaterials) {
+          shared2.vegMaterials.dispose();
+          shared2.vegMaterials = null;
         }
-        for (const m of Object.values(shared.mats)) {
+        for (const m of Object.values(shared2.mats)) {
           if (m && m.dispose) m.dispose();
         }
         for (const [k, t] of Object.entries(TEX)) if (t && t.dispose && !(cfg.textures && cfg.textures[k])) t.dispose();
@@ -35649,7 +35774,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     const colliderChanged = (c) => {
       if (c && cfg.onCollider) cfg.onCollider(c);
     };
-    const shared = { mats: null, quality: cfg.quality === "game" ? "game" : "high" };
+    const shared2 = { mats: null, quality: cfg.quality === "game" ? "game" : "high" };
     const seedKey = (id) => {
       if (cfg.seedKey && id != null) {
         const k = cfg.seedKey(String(id));
@@ -35658,61 +35783,61 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       return id;
     };
     const K = { t: createTranslator2(cfg.locale), seedKey, THREE: shapeGeometries(THREE), cfg, DOC, PROPS, Reflector, FLEET, HP, invalidate, invalidateShadow, colliderChanged, VERSION, rectsOf, isOpenArea, OPEN_ROOM_TYPES: OPEN_ROOM_TYPES2 };
-    installKernelGeometry(K, shared);
-    installKernelNoise(K, shared);
-    installMaterialsTextures(K, shared);
-    installMaterialsMaterials(K, shared);
-    installKernelCloseScene(K, shared);
-    installHouseHelpers(K, shared);
-    installHouseWalls(K, shared);
-    installHouseDoors(K, shared);
-    installHouseWindows(K, shared);
-    installHouseFloors(K, shared);
-    installHouseStairs(K, shared);
-    installLightsFixtures(K, shared);
-    installLightsDecor(K, shared);
-    installLotTerrain(K, shared);
-    installLotPerimeter(K, shared);
-    installLotGates(K, shared);
-    installRoofRoofs(K, shared);
-    installRoofGutters(K, shared);
-    installRoofSlabs(K, shared);
-    installRoofTiles(K, shared);
-    installRoofRect(K, shared);
-    installMirrors(K, shared);
-    installCars(K, shared);
-    installHouseBuilding(K, shared);
-    installUtilitiesWater(K, shared);
-    installUtilitiesElectrical(K, shared);
-    installHouseBaseboard(K, shared);
-    installUtilitiesSolar(K, shared);
-    installHouseOutbuildings(K, shared);
-    installFurnitureApi(K, shared);
-    installFurnitureBuilders(K, shared);
-    installFurnitureTypeTable(K, shared);
-    installFurnitureTaps(K, shared);
-    installFurnitureFixtures(K, shared);
-    installFurniturePlants(K, shared);
-    installFurnitureYard(K, shared);
-    installFurnitureExtraTypes(K, shared);
-    installFurniturePlaceItems(K, shared);
-    installVegetationBridge(K, shared);
-    installInteractionState(K, shared);
-    installInteractionCollision(K, shared);
-    installInteractionItems(K, shared);
-    installInteractionFittings(K, shared);
-    installInteractionDoors(K, shared);
-    installInteractionTarget(K, shared);
-    installInteractablesBridge(K, shared);
-    installAnimationClotheslines(K, shared);
-    installBuildInstance(K, shared);
-    installInteractablesKit(K, shared);
-    installLightsRoomLight(K, shared);
-    installDestructionPieces(K, shared);
-    installDestructionBreach(K, shared);
-    installDestructionWorld(K, shared);
-    installBuildBuild(K, shared);
-    return buildApi(K, shared);
+    installKernelGeometry(K, shared2);
+    installKernelNoise(K, shared2);
+    installMaterialsTextures(K, shared2);
+    installMaterialsMaterials(K, shared2);
+    installKernelCloseScene(K, shared2);
+    installHouseHelpers(K, shared2);
+    installHouseWalls(K, shared2);
+    installHouseDoors(K, shared2);
+    installHouseWindows(K, shared2);
+    installHouseFloors(K, shared2);
+    installHouseStairs(K, shared2);
+    installLightsFixtures(K, shared2);
+    installLightsDecor(K, shared2);
+    installLotTerrain(K, shared2);
+    installLotPerimeter(K, shared2);
+    installLotGates(K, shared2);
+    installRoofRoofs(K, shared2);
+    installRoofGutters(K, shared2);
+    installRoofSlabs(K, shared2);
+    installRoofTiles(K, shared2);
+    installRoofRect(K, shared2);
+    installMirrors(K, shared2);
+    installCars(K, shared2);
+    installHouseBuilding(K, shared2);
+    installUtilitiesWater(K, shared2);
+    installUtilitiesElectrical(K, shared2);
+    installHouseBaseboard(K, shared2);
+    installUtilitiesSolar(K, shared2);
+    installHouseOutbuildings(K, shared2);
+    installFurnitureApi(K, shared2);
+    installFurnitureBuilders(K, shared2);
+    installFurnitureTypeTable(K, shared2);
+    installFurnitureTaps(K, shared2);
+    installFurnitureFixtures(K, shared2);
+    installFurniturePlants(K, shared2);
+    installFurnitureYard(K, shared2);
+    installFurnitureExtraTypes(K, shared2);
+    installFurniturePlaceItems(K, shared2);
+    installVegetationBridge(K, shared2);
+    installInteractionState(K, shared2);
+    installInteractionCollision(K, shared2);
+    installInteractionItems(K, shared2);
+    installInteractionFittings(K, shared2);
+    installInteractionDoors(K, shared2);
+    installInteractionTarget(K, shared2);
+    installInteractablesBridge(K, shared2);
+    installAnimationClotheslines(K, shared2);
+    installBuildInstance(K, shared2);
+    installInteractablesKit(K, shared2);
+    installLightsRoomLight(K, shared2);
+    installDestructionPieces(K, shared2);
+    installDestructionBreach(K, shared2);
+    installDestructionWorld(K, shared2);
+    installBuildBuild(K, shared2);
+    return buildApi(K, shared2);
   }
   var WOOD_THIN = 0.035;
   var BOARD_TOP_THICK = 0.07;
@@ -35817,12 +35942,12 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       }
       const n = counters.get(key2) ?? 0;
       counters.set(key2, n + 1);
-      let rotation = null;
+      let rotation2 = null;
       if (turned) {
         xyz.setFromQuaternion(q, "XYZ");
-        rotation = [xyz.x, xyz.y, xyz.z];
+        rotation2 = [xyz.x, xyz.y, xyz.z];
       }
-      drawn.push({ id: `${key2}_${n}`, key: key2, shape, position: [px - root.x, py, pz - root.z], rotation, color: color2, min: min2, max: max2 });
+      drawn.push({ id: `${key2}_${n}`, key: key2, shape, position: [px - root.x, py, pz - root.z], rotation: rotation2, color: color2, min: min2, max: max2 });
     };
     const A = {
       box(M, mat, x, y, z, bw, bh, bd, color2, ry = 0, rx = 0, rz = 0) {
@@ -35935,21 +36060,21 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     const seed = Math.round(opts.seed ?? 1);
     const plain2 = SHELVING.test(type) ? "paper" : "plastic";
     const root = { x: seed, z: 0, ry: 0, w, d, h, y: 0, base: 0, palette: o.palette, seed: `furniture_${type}_${seed}` };
-    const { K, shared } = renderer.internals;
+    const { K, shared: shared2 } = renderer.internals;
     const before = K.PARTS.length;
     const made = recordSpec(
       THREE,
       type,
       root,
       (A) => {
-        const saved = { api0: shared.api0, ctx: shared.ctx };
-        shared.api0 = A;
-        shared.ctx = shared.ctx ?? {};
+        const saved = { api0: shared2.api0, ctx: shared2.ctx };
+        shared2.api0 = A;
+        shared2.ctx = shared2.ctx ?? {};
         try {
           ent.f(root, A);
         } finally {
-          shared.api0 = saved.api0;
-          shared.ctx = saved.ctx;
+          shared2.api0 = saved.api0;
+          shared2.ctx = saved.ctx;
         }
       },
       { materials: { plain: plain2, ...o.materials }, chairs: o.chairs, carcass: SHELVING.test(type) }
@@ -37466,7 +37591,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     const registry = createSoundRegistry(options.banks);
     const voices = createVoiceManager({ ...options.groups ? { groups: options.groups } : {}, ...options.maxVoices === void 0 ? {} : { maxVoices: options.maxVoices } });
     const engineRandom = createRng3(seed);
-    const shared = createNoiseStore(engineRandom);
+    const shared2 = createNoiseStore(engineRandom);
     const busSettings = /* @__PURE__ */ new Map();
     const busNodes = /* @__PURE__ */ new Map();
     const meters = /* @__PURE__ */ new Map();
@@ -37505,7 +37630,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       if (!created) return null;
       context = created;
       chain = buildChain(created, mix3, engineRandom);
-      if (mix3.noise.create === "eager") noiseBuffer(shared, created, mix3.noise.seconds);
+      if (mix3.noise.create === "eager") noiseBuffer(shared2, created, mix3.noise.seconds);
       for (const [bus, setting] of Object.entries(mix3.buses ?? {})) {
         busSettings.set(bus, { ...setting, ...busSettings.get(bus) });
       }
@@ -37624,8 +37749,8 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     const loopHost = {
       ready,
       output: outputFor,
-      prepareNoise: () => context && prepareNoise(shared, context, mix3.noise.seconds),
-      noise: () => noiseBuffer(shared, context, mix3.noise.seconds),
+      prepareNoise: () => context && prepareNoise(shared2, context, mix3.noise.seconds),
+      noise: () => noiseBuffer(shared2, context, mix3.noise.seconds),
       register: (loop) => void loops.add(loop),
       unregister: (loop) => void loops.delete(loop)
     };
@@ -37633,7 +37758,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       registry,
       register: (bank) => registry.register(bank),
       plan: (id, playOptions = {}) => planWith(id, playOptions, createRng3(playOptions.seed ?? seed)),
-      play: (id, playOptions = {}) => playWith(id, playOptions, randomFor(playOptions), shared),
+      play: (id, playOptions = {}) => playWith(id, playOptions, randomFor(playOptions), shared2),
       playPlan(plan, playOptions = {}) {
         const audio = ready();
         if (!audio) return null;
@@ -37641,13 +37766,13 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         const recipe = { id: plan.id, bus: plan.bus, layers: [], sources: [], priority: plan.priority, ...plan.group ? { group: plan.group } : {} };
         const voiceId = plan.silent ? void 0 : admit(recipe, plan.level, plan.distance);
         if (voiceId === null) return null;
-        if (planUsesNoise(plan)) prepareNoise(shared, audio, mix3.noise.seconds);
-        return start(plan, shared, voiceId, playOptions.delay);
+        if (planUsesNoise(plan)) prepareNoise(shared2, audio, mix3.noise.seconds);
+        return start(plan, shared2, voiceId, playOptions.delay);
       },
       loop: (id, loopOptions = {}) => createLoopHandle(registry.loop(id), loopHost, loopOptions.volume),
       channel(channelOptions) {
         const random = channelOptions.random ?? (channelOptions.seed === void 0 ? engineRandom : createRng3(channelOptions.seed));
-        const store = channelOptions.ownNoise ? createNoiseStore(random) : shared;
+        const store = channelOptions.ownNoise ? createNoiseStore(random) : shared2;
         return {
           random,
           play: (id, playOptions = {}) => playWith(id, playOptions, random, store),
@@ -37669,7 +37794,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         if (!context || !chain) return;
         const old = chain;
         chain = buildChain(context, mix3, engineRandom);
-        if (mix3.noise.seconds !== previous.noise.seconds) shared.reset();
+        if (mix3.noise.seconds !== previous.noise.seconds) shared2.reset();
         for (const node of busNodes.values()) {
           node.disconnect();
           node.connect(chain.master);
@@ -37688,7 +37813,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       warmUp() {
         const audio = ready();
         if (!audio) return false;
-        noiseBuffer(shared, audio, mix3.noise.seconds);
+        noiseBuffer(shared2, audio, mix3.noise.seconds);
         return true;
       },
       level(bus) {
@@ -37723,7 +37848,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         chain = null;
         busNodes.clear();
         meters.clear();
-        shared.reset();
+        shared2.reset();
       }
     };
   }
@@ -38809,14 +38934,14 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     const distanceCurve = { ...GAME_DISTANCE_CURVE, ...options.distance };
     const mechanicalTable = { ...MECHANICAL_SOUNDS, ...options.mechanical };
     const cueTable = { ...RELOAD_CUES, ...options.reloadCues };
-    const shared = options.engine;
-    const engine = shared ?? createAudioEngine({
+    const shared2 = options.engine;
+    const engine = shared2 ?? createAudioEngine({
       seed,
       mix: { ...MIX_PROFILES.game, master: volume, noise: { seconds: NOISE_SECONDS, create: "eager" } },
       maxVoices: Number.POSITIVE_INFINITY,
       ...options.createContext ? { createContext: options.createContext } : {}
     });
-    const channel = shared && options.seed !== void 0 ? shared.channel({ seed }) : engine.channel({});
+    const channel = shared2 && options.seed !== void 0 ? shared2.channel({ seed }) : engine.channel({});
     engine.register({ id: `weapons_three@${classBurstId(distanceCurve)}`, sounds: weaponRecipes(distanceCurve) });
     const classBurst = classBurstId(distanceCurve);
     const burst2 = (config) => {
@@ -38903,11 +39028,11 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       },
       setVolume(next) {
         const level = Math.max(0, Math.min(1, next));
-        if (shared) shared.setBus("weapons", { gain: level });
+        if (shared2) shared2.setBus("weapons", { gain: level });
         else engine.setMaster(level);
       },
       dispose() {
-        if (!shared) engine.dispose();
+        if (!shared2) engine.dispose();
       }
     };
   }
@@ -39789,10 +39914,10 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       materials.push(material);
       return material;
     };
-    const mesh3 = (geometry, material, position = [0, 0, 0], rotation = [0, 0, 0], scale) => {
+    const mesh3 = (geometry, material, position = [0, 0, 0], rotation2 = [0, 0, 0], scale) => {
       const object2 = new T2.Mesh(geometry, material);
       object2.position.set(...position);
-      object2.rotation.set(...rotation);
+      object2.rotation.set(...rotation2);
       if (scale) object2.scale.set(...scale);
       return object2;
     };
@@ -44069,8 +44194,8 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     return G(
       mesh3(bx(0.9, 1.3, 0.46), wood(4861979), [0, 0.35, 0]),
       mesh3(bx(0.92, 0.5, 0.5), cloth2(2829099), [0, 0.1, 0]),
-      ...limbs.map(([geometry, position, rotation]) => mesh3(geometry, limbMaterial, [...position], [...rotation])),
-      ...strings.map(([geometry, position, rotation]) => mesh3(geometry, stringMaterial, [...position], [...rotation]))
+      ...limbs.map(([geometry, position, rotation2]) => mesh3(geometry, limbMaterial, [...position], [...rotation2])),
+      ...strings.map(([geometry, position, rotation2]) => mesh3(geometry, stringMaterial, [...position], [...rotation2]))
     );
   };
   var crossbow = ({ mesh: mesh3, bx, G, wood, metal: metal2, cloth: cloth2 }) => {
@@ -44127,8 +44252,8 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     return G(
       mesh3(cyl(0.12, 0.1, 0.65, 8), frame2, [0, -0.425, 0]),
       mesh3(cyl(0.126, 0.126, 0.3, 8), cloth2(8007455), [0, -0.5, 0]),
-      ...arms.map(([geometry, position, rotation]) => mesh3(geometry, frame2, [...position], [...rotation])),
-      ...bands.map(([geometry, position, rotation]) => mesh3(geometry, band, [...position], [...rotation])),
+      ...arms.map(([geometry, position, rotation2]) => mesh3(geometry, frame2, [...position], [...rotation2])),
+      ...bands.map(([geometry, position, rotation2]) => mesh3(geometry, band, [...position], [...rotation2])),
       mesh3(bx(0.26, 0.2, 0.05), cloth2(9067061), [0, 0.2, 0])
     );
   };
@@ -47728,7 +47853,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     const standard = (color2, roughness = 0.7, metalness = 0.2, extra = {}) => new THREE.MeshStandardMaterial({ color: color2, roughness, metalness, ...extra });
     const basic = (color2, extra = {}) => new THREE.MeshBasicMaterial({ color: color2, ...extra });
     const additive = { transparent: true, opacity: 0.95, blending: THREE.AdditiveBlending, depthWrite: false };
-    return {
+    const materials = {
       metal: standard(3422010, 0.42, 0.75),
       steel: standard(7106418, 0.32, 0.85),
       steelL: standard(9080208, 0.28, 0.9),
@@ -47767,6 +47892,8 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       bakelite: standard(6958620, 0.6, 0),
       polyMag: standard(2763302, 0.85, 0)
     };
+    markShared(...Object.values(materials));
+    return materials;
   };
   var kits = /* @__PURE__ */ new WeakMap();
   function modelKit(host) {
@@ -47795,6 +47922,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         let geometry = geometries.get(key2);
         if (!geometry) {
           geometry = radius > 25e-5 ? createRoundedBoxGeometry(THREE, w, h, d, 2, radius) : new THREE.BoxGeometry(w, h, d);
+          markShared(geometry);
           geometries.set(key2, geometry);
         }
         const mesh3 = place(parent, shadowed(new THREE.Mesh(geometry, material)), x, y, z);
@@ -51916,11 +52044,231 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       glow.outIntensity = glow.i * Math.pow(1 - age, glow.curve) * flicker;
     }
   }
+  var LEHMER_MULTIPLIER = 16807;
+  var LEHMER_MODULUS = 2147483647;
+  var HASH_MIX = 2654435761;
+  function normalizeLehmerSeed(seed) {
+    const whole = Math.floor(Math.abs(seed)) % (LEHMER_MODULUS - 1);
+    return whole === 0 ? 1 : whole;
+  }
+  function lehmer(seed) {
+    let state = normalizeLehmerSeed(seed);
+    const next = () => {
+      state = state * LEHMER_MULTIPLIER % LEHMER_MODULUS;
+      return (state - 1) / (LEHMER_MODULUS - 1);
+    };
+    return {
+      next,
+      between: (min2, max2) => min2 + (max2 - min2) * next(),
+      direction(out) {
+        const up = next() * 2 - 1;
+        const angle = next() * Math.PI * 2;
+        const ring22 = Math.sqrt(1 - up * up);
+        out.x = ring22 * Math.cos(angle);
+        out.y = up;
+        out.z = ring22 * Math.sin(angle);
+        return out;
+      },
+      get state() {
+        return state;
+      }
+    };
+  }
+  function mixEventSeed(eventSeed) {
+    let mixed = Math.imul((eventSeed | 0) ^ HASH_MIX, 2246822507);
+    mixed ^= mixed >>> 13;
+    mixed = Math.imul(mixed, 3266489909);
+    mixed ^= mixed >>> 16;
+    return (mixed >>> 0) % (LEHMER_MODULUS - 1) + 1;
+  }
+  function streamFor3(eventSeed) {
+    return lehmer(mixEventSeed(eventSeed));
+  }
+  var SKIN = 5e-3;
+  var MAX_PAD = 0.45;
+  function rotation(q) {
+    const [x, y, z, w] = q ?? [0, 0, 0, 1];
+    const n = Math.hypot(x, y, z, w) || 1;
+    const qx = x / n;
+    const qy = y / n;
+    const qz = z / n;
+    const qw = w / n;
+    return new Float64Array([
+      1 - 2 * (qy * qy + qz * qz),
+      2 * (qx * qy - qz * qw),
+      2 * (qx * qz + qy * qw),
+      2 * (qx * qy + qz * qw),
+      1 - 2 * (qx * qx + qz * qz),
+      2 * (qy * qz - qx * qw),
+      2 * (qx * qz - qy * qw),
+      2 * (qy * qz + qx * qw),
+      1 - 2 * (qx * qx + qy * qy)
+    ]);
+  }
+  var Enclosures = class {
+    constructor(seed = 20973) {
+      __publicField2(this, "spaces", /* @__PURE__ */ new Map());
+      __publicField2(this, "list", []);
+      __publicField2(this, "random");
+      __publicField2(this, "out", { x: 0, y: 0, z: 0, nx: 0, ny: 0, nz: 0 });
+      __publicField2(this, "l0", new Float64Array(3));
+      __publicField2(this, "l1", new Float64Array(3));
+      __publicField2(this, "q", new Float64Array(3));
+      this.random = lehmer(seed);
+    }
+    get empty() {
+      return this.list.length === 0;
+    }
+    get size() {
+      return this.list.length;
+    }
+    /** Declares, moves or (with `null`) ends the space `id`. */
+    set(id, enclosure) {
+      if (!enclosure) {
+        if (this.spaces.delete(id)) this.list = [...this.spaces.values()];
+        return;
+      }
+      const [hx, hy, hz] = enclosure.halfSize;
+      const space = {
+        cx: enclosure.center[0],
+        cy: enclosure.center[1],
+        cz: enclosure.center[2],
+        hx: Math.abs(hx),
+        hy: Math.abs(hy),
+        hz: Math.abs(hz),
+        r: rotation(enclosure.orientation),
+        radius: Math.hypot(hx, hy, hz),
+        openings: enclosure.openings ?? [],
+        leak: Math.max(0, enclosure.leak ?? 0)
+      };
+      const old = this.spaces.get(id);
+      this.spaces.set(id, space);
+      const at3 = old ? this.list.indexOf(old) : -1;
+      if (at3 >= 0) this.list[at3] = space;
+      else this.list.push(space);
+    }
+    get(id) {
+      const s = this.spaces.get(id);
+      if (!s) return void 0;
+      return { center: [s.cx, s.cy, s.cz], halfSize: [s.hx, s.hy, s.hz], openings: s.openings, leak: s.leak };
+    }
+    ids() {
+      return [...this.spaces.keys()];
+    }
+    clear() {
+      this.spaces.clear();
+      this.list = [];
+    }
+    /** Whether a point is inside any space (on the inside of its walls). */
+    inside(x, y, z) {
+      for (const s of this.list) {
+        this.toLocal(s, x, y, z, this.l0);
+        if (Math.abs(this.l0[0]) <= s.hx && Math.abs(this.l0[1]) <= s.hy && Math.abs(this.l0[2]) <= s.hz) return true;
+      }
+      return false;
+    }
+    toLocal(s, x, y, z, out) {
+      const dx = x - s.cx;
+      const dy = y - s.cy;
+      const dz = z - s.cz;
+      const r = s.r;
+      out[0] = r[0] * dx + r[3] * dy + r[6] * dz;
+      out[1] = r[1] * dx + r[4] * dy + r[7] * dz;
+      out[2] = r[2] * dx + r[5] * dy + r[8] * dz;
+    }
+    /** Passes at `rate` per second. */
+    chance(rate, dt) {
+      return rate > 0 && this.random.next() < 1 - Math.exp(-rate * dt);
+    }
+    /** The opening the wall point `q` (local) is in lets it through now. */
+    through(s, q, dt) {
+      for (const o of s.openings) {
+        if (Math.abs(q[0] - o.center[0]) > o.halfSize[0] || Math.abs(q[1] - o.center[1]) > o.halfSize[1] || Math.abs(q[2] - o.center[2]) > o.halfSize[2]) continue;
+        if (o.rate === void 0 || this.chance(o.rate, dt)) return true;
+      }
+      return this.chance(s.leak, dt);
+    }
+    confine(x0, y0, z0, x1, y1, z1, pad, dt) {
+      const list2 = this.list;
+      if (list2.length === 0) return false;
+      const p = Math.min(Math.max(0, pad), MAX_PAD);
+      const l0 = this.l0;
+      const l1 = this.l1;
+      const q = this.q;
+      for (const s of list2) {
+        const reach = s.radius + p + 0.05;
+        const dx = x1 - s.cx;
+        const dy = y1 - s.cy;
+        const dz = z1 - s.cz;
+        if (dx * dx + dy * dy + dz * dz > reach * reach) {
+          const ex = x0 - s.cx;
+          const ey = y0 - s.cy;
+          const ez = z0 - s.cz;
+          if (ex * ex + ey * ey + ez * ez > reach * reach) continue;
+        }
+        this.toLocal(s, x0, y0, z0, l0);
+        this.toLocal(s, x1, y1, z1, l1);
+        const h = [s.hx, s.hy, s.hz];
+        const in0 = Math.abs(l0[0]) <= s.hx && Math.abs(l0[1]) <= s.hy && Math.abs(l0[2]) <= s.hz;
+        let axis2 = 0;
+        let sign2 = 1;
+        if (in0) {
+          if (Math.abs(l1[0]) <= s.hx && Math.abs(l1[1]) <= s.hy && Math.abs(l1[2]) <= s.hz) continue;
+          for (let a = 0; a < 3; a++) q[a] = Math.min(h[a], Math.max(-h[a], l1[a]));
+          if (this.through(s, q, dt)) continue;
+          let worst = -Infinity;
+          for (let a = 0; a < 3; a++) {
+            const over = Math.abs(l1[a]) - h[a];
+            if (over > worst) {
+              worst = over;
+              axis2 = a;
+            }
+          }
+          sign2 = l1[axis2] < 0 ? -1 : 1;
+          for (let a = 0; a < 3; a++) l1[a] = Math.min(h[a] - SKIN, Math.max(-(h[a] - SKIN), l1[a]));
+          sign2 = -sign2;
+        } else {
+          const padded0 = Math.abs(l0[0]) <= s.hx + p && Math.abs(l0[1]) <= s.hy + p && Math.abs(l0[2]) <= s.hz + p;
+          const bound = padded0 ? 0 : p;
+          if (!(Math.abs(l1[0]) <= s.hx + bound && Math.abs(l1[1]) <= s.hy + bound && Math.abs(l1[2]) <= s.hz + bound)) continue;
+          for (let a = 0; a < 3; a++) q[a] = Math.min(h[a], Math.max(-h[a], l1[a]));
+          if (this.through(s, q, dt)) continue;
+          let worst = -Infinity;
+          for (let a = 0; a < 3; a++) {
+            const over = Math.abs(l0[a]) - (h[a] + bound);
+            if (over > worst) {
+              worst = over;
+              axis2 = a;
+            }
+          }
+          sign2 = l0[axis2] < 0 ? -1 : 1;
+          l1[axis2] = sign2 * (h[axis2] + bound + SKIN);
+        }
+        const r = s.r;
+        const out = this.out;
+        out.x = s.cx + r[0] * l1[0] + r[1] * l1[1] + r[2] * l1[2];
+        out.y = s.cy + r[3] * l1[0] + r[4] * l1[1] + r[5] * l1[2];
+        out.z = s.cz + r[6] * l1[0] + r[7] * l1[1] + r[8] * l1[2];
+        out.nx = r[axis2] * sign2;
+        out.ny = r[3 + axis2] * sign2;
+        out.nz = r[6 + axis2] * sign2;
+        return true;
+      }
+      return false;
+    }
+  };
+  function slideAlong(out, vx2, vy2, vz2) {
+    const into = vx2 * out.nx + vy2 * out.ny + vz2 * out.nz;
+    if (into >= 0) return [vx2, vy2, vz2];
+    return [vx2 - into * out.nx, vy2 - into * out.ny, vz2 - into * out.nz];
+  }
   var FLOOR_FRACTION = 0.4;
   var FLOOR_BOUNCE = -0.2;
   var ARRIVAL_FRAME = 30;
   var ARRIVAL_BASE = 0.3;
   var GROWTH_CAP_SECONDS = 3.5;
+  var CARRIED_KINDS = [true, true, false, true, false];
+  var PAD_OF_SIZE = 0.35;
   function createPuffPool(capacity) {
     const placeholder = { next: () => 0, between: (min2) => min2, direction: (out) => out, state: 0 };
     return new OrderedPool(capacity, () => ({
@@ -52015,13 +52363,24 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       if (puff3.vy < 0) puff3.vy *= FLOOR_BOUNCE;
     }
   }
-  function updatePuffs(pool, dt, wind) {
+  function updatePuffs(pool, dt, wind, confiner) {
     pool.compact(ageOrKeep2, dt);
+    const confining = confiner !== void 0 && !confiner.empty;
     for (const puff3 of pool.items) {
       const age = puff3.t / puff3.life;
       const heat = puff3.h0 > 0 ? puff3.h0 * Math.pow(Math.max(0, 1 - puff3.t / puff3.hl), 1.25) : 0;
+      const x0 = puff3.x;
+      const y0 = puff3.y;
+      const z0 = puff3.z;
       if (puff3.ring) moveOnRing(puff3, puff3.ring, wind);
       else moveFree(puff3, dt, age, heat, wind);
+      if (confining && CARRIED_KINDS[puff3.kind] && confiner.confine(x0, y0, z0, puff3.x, puff3.y, puff3.z, puff3.size * PAD_OF_SIZE, dt)) {
+        const out = confiner.out;
+        puff3.x = out.x;
+        puff3.y = out.y;
+        puff3.z = out.z;
+        [puff3.vx, puff3.vy, puff3.vz] = slideAlong(out, puff3.vx, puff3.vy, puff3.vz);
+      }
       const size = puff3.s0 + (puff3.s1 - puff3.s0) * (1 - Math.exp(-puff3.t * puff3.gk)) + puff3.sg * Math.min(puff3.t, GROWTH_CAP_SECONDS);
       puff3.size = size * Math.min(1, puff3.t * ARRIVAL_FRAME + ARRIVAL_BASE);
       puff3.age = age;
@@ -52547,10 +52906,10 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       ])
     ]
   };
-  function localToWorld(translation, rotation, local2) {
+  function localToWorld(translation, rotation2, local2) {
     const [x, y, z] = local2;
-    const [a, c, e] = [Math.cos(rotation[0]), Math.cos(rotation[1]), Math.cos(rotation[2])];
-    const [b, d, f] = [Math.sin(rotation[0]), Math.sin(rotation[1]), Math.sin(rotation[2])];
+    const [a, c, e] = [Math.cos(rotation2[0]), Math.cos(rotation2[1]), Math.cos(rotation2[2])];
+    const [b, d, f] = [Math.sin(rotation2[0]), Math.sin(rotation2[1]), Math.sin(rotation2[2])];
     const [ae, af, be, bf] = [a * e, a * f, b * e, b * f];
     return [
       c * e * x + -c * f * y + d * z + translation[0],
@@ -54213,46 +54572,6 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
   var ALL_EFFECTS = [BLOOD_HIT, HEADSHOT, DISMEMBER, BLOATER_CLOUD, SCREAMER_SHRIEK, CORPSE_DECAY, REANIMATION, EYES_IN_FOG, MUZZLE_FLASH, IMPACT_BY_MATERIAL, PENETRATION, CASINGS_AND_MAGAZINE, MOLOTOV, GRENADE, EXPLOSIVE_BARREL, SHOPFRONT_GLASS, DOOR_STAGES, BUILDING_COLLAPSE, BLOCK_WALL, METAL_DOOR_EFFECT, IRON_RAILING, WOODEN_FENCE, HIT_POINT_BREAKAGE, PRESSURE_CYLINDERS, BUILDING_FIRE, RAIN_AND_PUDDLES, FOG_AND_ASH, SCRAPING_SPARKS, ENGINE_SMOKE, FUEL_LEAK, CAR_EXPLOSION, WINDSHIELD, HEADLIGHTS_IN_RAIN, DAMAGE_AND_BITE, INFECTION_PHASES, PANIC, BLOATER_BLINDNESS, CAMPFIRE, COUGH_AND_BREATH];
   var WORKSHOP_EFFECTS = Object.fromEntries(ALL_EFFECTS.map((effect) => [effect.id, effect]));
   var GAME_EFFECTS = { ...WORKSHOP_EFFECTS, ...Object.fromEntries([...EVENT_EFFECTS, ...VIEWMODEL_EFFECTS, ...VEHICLE_EFFECTS].map((effect) => [effect.id, effect])) };
-  var LEHMER_MULTIPLIER = 16807;
-  var LEHMER_MODULUS = 2147483647;
-  var HASH_MIX = 2654435761;
-  function normalizeLehmerSeed(seed) {
-    const whole = Math.floor(Math.abs(seed)) % (LEHMER_MODULUS - 1);
-    return whole === 0 ? 1 : whole;
-  }
-  function lehmer(seed) {
-    let state = normalizeLehmerSeed(seed);
-    const next = () => {
-      state = state * LEHMER_MULTIPLIER % LEHMER_MODULUS;
-      return (state - 1) / (LEHMER_MODULUS - 1);
-    };
-    return {
-      next,
-      between: (min2, max2) => min2 + (max2 - min2) * next(),
-      direction(out) {
-        const up = next() * 2 - 1;
-        const angle = next() * Math.PI * 2;
-        const ring22 = Math.sqrt(1 - up * up);
-        out.x = ring22 * Math.cos(angle);
-        out.y = up;
-        out.z = ring22 * Math.sin(angle);
-        return out;
-      },
-      get state() {
-        return state;
-      }
-    };
-  }
-  function mixEventSeed(eventSeed) {
-    let mixed = Math.imul((eventSeed | 0) ^ HASH_MIX, 2246822507);
-    mixed ^= mixed >>> 13;
-    mixed = Math.imul(mixed, 3266489909);
-    mixed ^= mixed >>> 16;
-    return (mixed >>> 0) % (LEHMER_MODULUS - 1) + 1;
-  }
-  function streamFor3(eventSeed) {
-    return lehmer(mixEventSeed(eventSeed));
-  }
   var TABLE = {
     concrete: { dust: 9078138, chip: 7236195, spark: 2 },
     metal: { dust: 0, chip: 0, spark: 18 },
@@ -55355,12 +55674,12 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     }
     function drawing(entry2, action) {
       const context = engine.context;
-      const shared = context.random;
+      const shared2 = context.random;
       if (entry2.random) context.random = entry2.random;
       try {
         action();
       } finally {
-        context.random = shared;
+        context.random = shared2;
       }
     }
     return {
@@ -55556,8 +55875,8 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
   function addScorch(store, random, x, z, radius) {
     const variant = Math.floor(random.next() * SCORCH_VARIANTS);
     const lift = 0.03 + nextLift(store) * 1e-3;
-    const rotation = random.next() * 6;
-    store.add({ kind: "scorch", x, z, radius, variant, lift, rotation });
+    const rotation2 = random.next() * 6;
+    store.add({ kind: "scorch", x, z, radius, variant, lift, rotation: rotation2 });
   }
   function addRimRocks(store, ground, random, x, z, radius) {
     const count = Math.round(6 + radius * 7);
@@ -55586,8 +55905,8 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
   function addCrater(store, ground, random, spec) {
     ground?.dent(random, spec.x, spec.z, spec.radius, spec.depth);
     if (!spec.marks) return;
-    const rotation = random.next() * 6;
-    store.add({ kind: "dirt", x: spec.x, z: spec.z, radius: spec.radius * 1.02, lift: 0.045, rotation });
+    const rotation2 = random.next() * 6;
+    store.add({ kind: "dirt", x: spec.x, z: spec.z, radius: spec.radius * 1.02, lift: 0.045, rotation: rotation2 });
     addRimRocks(store, ground, random, spec.x, spec.z, spec.radius);
   }
   function addBloodSplat(store, ground, random, spec) {
@@ -56143,6 +56462,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     state.gas = Math.max(0, state.gas - dt / DECAY.gasSeconds);
     state.beat *= Math.exp(-DECAY.beat * dt);
   }
+  var PAD_OF_SIZE2 = 0.35;
   var clamp4 = (v, lo, hi) => v < lo ? lo : v > hi ? hi : v;
   var lerp4 = (a, b, t) => a + (b - a) * t;
   function rgb(hex2) {
@@ -56302,9 +56622,20 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
           vy2 *= k;
           vz2 *= k;
         }
-        const x = this.position[i3] + vx2 * dt;
+        let x = this.position[i3] + vx2 * dt;
         let y = this.position[i3 + 1] + vy2 * dt;
-        const z = this.position[i3 + 2] + vz2 * dt;
+        let z = this.position[i3 + 2] + vz2 * dt;
+        const confiner = host.confiner;
+        if (def.carried && confiner && !confiner.empty) {
+          const pad = this.size0[i] * lerp4(1, def.grow, t) * PAD_OF_SIZE2;
+          if (confiner.confine(this.position[i3], this.position[i3 + 1], this.position[i3 + 2], x, y, z, pad, dt)) {
+            const out = confiner.out;
+            x = out.x;
+            y = out.y;
+            z = out.z;
+            [vx2, vy2, vz2] = slideAlong(out, vx2, vy2, vz2);
+          }
+        }
         if (def.ground !== "none") {
           const own = this.floor[i];
           const gy = Number.isNaN(own) ? host.groundAt(x, z) + 5e-3 : own;
@@ -56390,7 +56721,8 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       alpha: 0.35,
       fadeIn: 0.15,
       cone: 0.6,
-      ground: "none"
+      ground: "none",
+      carried: true
     },
     sparks: {
       id: "sparks",
@@ -56434,7 +56766,8 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       alpha: 0.4,
       fadeIn: 0.1,
       cone: 0.4,
-      ground: "none"
+      ground: "none",
+      carried: true
     },
     shards: {
       id: "shards",
@@ -56592,7 +56925,8 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       fadeIn: 0.1,
       cone: 0.5,
       ground: "stop",
-      flutter: 0.6
+      flutter: 0.6,
+      carried: true
     },
     steam: {
       id: "steam",
@@ -56614,7 +56948,8 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       alpha: 0.35,
       fadeIn: 0.15,
       cone: 0.6,
-      ground: "none"
+      ground: "none",
+      carried: true
     },
     flash: {
       id: "flash",
@@ -56747,7 +57082,8 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       const host = {
         groundAt: this.options.groundAt,
         gravity: this.options.gravity,
-        land: (owner, x, y, z, color2, tag) => this.listeners.get(owner)?.(x, y, z, color2, tag)
+        land: (owner, x, y, z, color2, tag) => this.listeners.get(owner)?.(x, y, z, color2, tag),
+        ...this.options.confiner ? { confiner: this.options.confiner } : {}
       };
       if (this.additive.live > 0 || this.additive.drawCount > 0) this.additive.update(dt, host);
       if (this.normal.live > 0 || this.normal.drawCount > 0) this.normal.update(dt, host);
@@ -56953,8 +57289,8 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
      * Takes away the marks inside a box: world `center`, `half` extents along the axes of the world `rotation` (a quaternion, x y z w; none means the
      * world axes). The surface they were on is gone (a brick came out of a wall with its bullet holes). Returns how many went.
      */
-    clearInside(center, half, rotation = [0, 0, 0, 1]) {
-      const qx = -rotation[0], qy = -rotation[1], qz = -rotation[2], qw = rotation[3];
+    clearInside(center, half, rotation2 = [0, 0, 0, 1]) {
+      const qx = -rotation2[0], qy = -rotation2[1], qz = -rotation2[2], qw = rotation2[3];
       let gone = 0;
       for (const decal2 of this.decals) {
         if (!decal2.on) continue;
@@ -57075,10 +57411,14 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
   var DEFAULT_FADE_IN = 0.1;
   var FLOATS_PER_VECTOR = 3;
   var BYTE_MAX2 = 255;
+  var CARRIED_GRAVITY = 3;
+  var PAD_OF_SIZE3 = 0.35;
   var SpritePool = class {
-    constructor(capacity, context) {
+    /** `carried`: the normal-blend pool (smoke, dust, steam), whose light sprites go round the closed spaces; the additive one (flames, sparks) does not. */
+    constructor(capacity, context, carried = false) {
       __publicField2(this, "capacity", capacity);
       __publicField2(this, "context", context);
+      __publicField2(this, "carried", carried);
       __publicField2(this, "count", 0);
       __publicField2(this, "position");
       __publicField2(this, "velocity");
@@ -57178,6 +57518,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     }
     update(dt, leaveDecal) {
       const { position, velocity } = this;
+      const confiner = this.context.confiner;
       for (let index = this.count - 1; index >= 0; index--) {
         this.life[index] -= dt;
         if (this.life[index] <= 0) {
@@ -57191,9 +57532,25 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         velocity[offset] *= factor;
         velocity[offset + 1] *= factor;
         velocity[offset + 2] *= factor;
+        const x0 = position[offset];
+        const y0 = position[offset + 1];
+        const z0 = position[offset + 2];
         position[offset] += velocity[offset] * dt;
         position[offset + 1] += velocity[offset + 1] * dt;
         position[offset + 2] += velocity[offset + 2] * dt;
+        if (this.carried && confiner && !confiner.empty && Math.abs(this.gravity[index]) < CARRIED_GRAVITY) {
+          const size = this.startSize[index] * (1 + (this.growth[index] - 1) * age);
+          if (confiner.confine(x0, y0, z0, position[offset], position[offset + 1], position[offset + 2], size * PAD_OF_SIZE3, dt)) {
+            const out = confiner.out;
+            position[offset] = out.x;
+            position[offset + 1] = out.y;
+            position[offset + 2] = out.z;
+            const [vx2, vy2, vz2] = slideAlong(out, velocity[offset], velocity[offset + 1], velocity[offset + 2]);
+            velocity[offset] = vx2;
+            velocity[offset + 1] = vy2;
+            velocity[offset + 2] = vz2;
+          }
+        }
         const mode = this.groundMode[index];
         if (mode) {
           const groundHeight = this.context.groundAt(position[offset], position[offset + 2]);
@@ -57470,9 +57827,9 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       __publicField2(this, "placement");
       __publicField2(this, "accumulators", /* @__PURE__ */ new Map());
       const profile = options.profile ?? PROFILES.high;
-      this.context = { random: options.random, groundAt: options.groundAt ?? workshopGround, quality: { level: 0, mult: 1 }, trace: options.trace };
+      this.context = { random: options.random, groundAt: options.groundAt ?? workshopGround, quality: { level: 0, mult: 1 }, trace: options.trace, ...options.confiner ? { confiner: options.confiner } : {} };
       this.add = new SpritePool(profile.sprites.add, this.context);
-      this.normal = new SpritePool(profile.sprites.normal, this.context);
+      this.normal = new SpritePool(profile.sprites.normal, this.context, true);
       this.streaks = new StreakPool(profile.streaks, this.context);
       this.debris = new DebrisPool(this.context);
       this.decals = new DecalPool(this.context);
@@ -57660,12 +58017,14 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     const groundAt = options.groundAt ?? (ground ? (x, z) => ground.heightAt(x, z) : () => 0);
     const handles = { next: 0, events: 0 };
     const low = options.profile === "low";
+    const enclosures = new Enclosures(20973 + (options.seed ?? 0));
     const spriteSystem = new SpriteKindSystem({
       capacity: options.sprites?.capacity ?? (low ? 1250 : 2500),
       density: options.sprites?.density ?? (low ? 0.6 : 1),
       seed: 2654435761 + (options.seed ?? 0),
       groundAt,
       gravity: options.gravity ?? DEFAULT_GRAVITY,
+      confiner: enclosures,
       ...options.sprites?.kinds ? { kinds: options.sprites.kinds } : {}
     });
     const core = {
@@ -57715,7 +58074,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       return [camera2.x, camera2.y, camera2.z];
     }, forward: (local2) => [local2[0] ?? 0, local2[1] ?? 0, local2[2] ?? 0] };
     function workshop() {
-      return engine ?? (engine = new WorkshopEngine({ random: sharedRandom, profile, groundAt }));
+      return engine ?? (engine = new WorkshopEngine({ random: sharedRandom, profile, groundAt, confiner: enclosures }));
     }
     function effectPlayer() {
       return player ?? (player = createEffectPlayer({ engine: workshop(), effects, view }));
@@ -57774,6 +58133,10 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
           puff3.vz += dz * strength;
         }
       },
+      enclose(id, enclosure) {
+        enclosures.set(id, enclosure);
+      },
+      enclosures: () => enclosures,
       stop(handle) {
         player?.stop(handle);
         const fires = core.fires;
@@ -57801,7 +58164,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         core.clock.time += dt;
         core.schedule.update(core.clock.time);
         updateRings(core.rings, dt);
-        updatePuffs(core.puffs, dt, wind);
+        updatePuffs(core.puffs, dt, wind, enclosures);
         updateSparks(core.sparks, { dt, groundAt });
         updateGlows(core.glows, dt);
         updateShocks(core.shocks, core.puffs.items, dt);
@@ -59185,6 +59548,8 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
         });
       },
       stop: (handle) => world.stop(handle),
+      // a module's closed space (a shut car's cabin): the world's smoke, dust and steam go round it
+      enclose: (id, enclosure) => world.enclose(id, enclosure),
       configure(settings) {
         const band = settings.lod_band;
         if (typeof band === "string" && band in LOD_BANDS) world.forceLod(LOD_BANDS[band] ?? null);
@@ -59331,7 +59696,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
         if (random() < 0.9) context.effects.smoke(rocket.position.clone().addScaledVector(forward, -0.12), new THREE.Vector3((random() - 0.5) * 0.1, 0.05, (random() - 0.5) * 0.1), 0.02 + random() * 0.015, 2.2, 0.5);
       },
       () => {
-        rocket.removeFromParent();
+        discardObject3D(rocket);
         exhaust.geometry.dispose();
         exhaust.material.dispose();
         const remaining = (rocketsInFlight.get(light) ?? 1) - 1;
@@ -59668,7 +60033,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       session.model.inner.add(shell);
       shell.position.set(-0.25, 0, 0);
       world.schedule(0.02, 0.4, (eased) => shell.position.x = -0.25 + 0.6 * eased, () => {
-        shell.removeFromParent();
+        discardObject3D(shell);
       });
     }
   }
@@ -60226,7 +60591,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
     const release = () => {
       if (!session) return;
       session.attachments?.dispose();
-      session.model.root.removeFromParent();
+      discardObject3D(session.model.root);
       player = null;
       session = null;
       tasks = [];
@@ -62137,7 +62502,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       vessel.rings = group;
     };
     const clearRings = (vessel) => {
-      vessel.rings?.removeFromParent();
+      if (vessel.rings) discardObject3D(vessel.rings);
       vessel.rings = void 0;
     };
     const phaseOf = (vessel) => {
@@ -62226,7 +62591,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       }
     };
     const clearShells = () => {
-      for (const shell of shells) shell.mesh.removeFromParent();
+      discardObject3D(shells.map((shell) => shell.mesh));
       shells.length = 0;
     };
     const fullVitality = /* @__PURE__ */ new Map();