@adatechnology/game-floorplan-three 0.1.1 → 0.2.1

package/dist/index.global.js

@@ -27,10 +27,10 @@ var GameFloorplanThree = (() => {
     VERSION: () => VERSION,
     bindNavigator: () => bindNavigator,
     buildSpecimenMeshes: () => buildSpecimenMeshes,
-    create: () => create2,
+    create: () => create3,
     createFloorNavigator: () => createFloorNavigator,
     createFloorplanTestModule: () => createFloorplanTestModule,
-    createHouseRenderer: () => create2,
+    createHouseRenderer: () => create3,
     createHouseScenarios: () => createHouseScenarios,
     createTranslator: () => createTranslator,
     en: () => en,
@@ -54,6 +54,7 @@ var GameFloorplanThree = (() => {
     create: () => create,
     createNodeSkin: () => createNodeSkin,
     createRecorder: () => createRecorder,
+    createShapeRecorder: () => createShapeRecorder,
     hex: () => hex,
     listTypes: () => listTypes,
     locales: () => locales,
@@ -64,6 +65,228 @@ var GameFloorplanThree = (() => {
     seedOf: () => seedOf,
     shade: () => shade
   });
+
+  // ../game-shapes/dist/chunk-R4RY23RH.js
+  function normalMatrix(me) {
+    const n11 = me[0], n21 = me[1], n31 = me[2];
+    const n12 = me[4], n22 = me[5], n32 = me[6];
+    const n13 = me[8], n23 = me[9], n33 = me[10];
+    const t11 = n33 * n22 - n32 * n23;
+    const t12 = n32 * n13 - n33 * n12;
+    const t13 = n23 * n12 - n22 * n13;
+    const det = n11 * t11 + n21 * t12 + n31 * t13;
+    if (det === 0) return [0, 0, 0, 0, 0, 0, 0, 0, 0];
+    const detInv = 1 / det;
+    const te = [
+      t11 * detInv,
+      (n31 * n23 - n33 * n21) * detInv,
+      (n32 * n21 - n31 * n22) * detInv,
+      t12 * detInv,
+      (n33 * n11 - n31 * n13) * detInv,
+      (n31 * n12 - n32 * n11) * detInv,
+      t13 * detInv,
+      (n21 * n13 - n23 * n11) * detInv,
+      (n22 * n11 - n21 * n12) * detInv
+    ];
+    let tmp = te[1];
+    te[1] = te[3];
+    te[3] = tmp;
+    tmp = te[2];
+    te[2] = te[6];
+    te[6] = tmp;
+    tmp = te[5];
+    te[5] = te[7];
+    te[7] = tmp;
+    return te;
+  }
+  function transformPoint(e, x, y, z) {
+    const w = 1 / (e[3] * x + e[7] * y + e[11] * z + e[15]);
+    return [(e[0] * x + e[4] * y + e[8] * z + e[12]) * w, (e[1] * x + e[5] * y + e[9] * z + e[13]) * w, (e[2] * x + e[6] * y + e[10] * z + e[14]) * w];
+  }
+  var num = (v) => typeof v === "number" && Number.isFinite(v) ? null : "expected a finite number";
+  var bool = (v) => typeof v === "boolean" ? null : "expected a boolean";
+  var str = (v) => typeof v === "string" ? null : "expected a string";
+  var int = (min) => (v) => typeof v === "number" && Number.isInteger(v) && v >= min ? null : `expected an integer >= ${min}`;
+  var range = (lo, hi, loOpen = false) => (v) => typeof v === "number" && (loOpen ? v > lo : v >= lo) && v <= hi ? null : `expected a number in ${loOpen ? "(" : "["}${lo}, ${hi}]`;
+  var tuple = (n, item = num) => (v) => {
+    if (!Array.isArray(v) || v.length !== n) return `expected an array of ${n}`;
+    for (const x of v) if (item(x)) return `expected an array of ${n} numbers`;
+    return null;
+  };
+  var list = (item, min = 0) => (v) => {
+    if (!Array.isArray(v)) return "expected an array";
+    if (v.length < min) return `expected at least ${min} items`;
+    for (let i = 0; i < v.length; i++) {
+      const e = item(v[i]);
+      if (e) return `[${i}]: ${e}`;
+    }
+    return null;
+  };
+  var color = (v) => typeof v === "number" && Number.isInteger(v) && v >= 0 && v <= 16777215 || typeof v === "string" && /^#[0-9a-fA-F]{6}$/.test(v) ? null : 'expected 0xRRGGBB or "#rrggbb"';
+  var oneOf = (values) => (v) => values.includes(v) ? null : `expected one of ${values.map((x) => JSON.stringify(x)).join(", ")}`;
+  var object = (fields, required = []) => (v) => {
+    if (!v || typeof v !== "object" || Array.isArray(v)) return "expected an object";
+    const record = v;
+    for (const key of required) if (record[key] === void 0) return `${key}: required`;
+    for (const key of Object.keys(record)) {
+      if (record[key] === void 0) continue;
+      const check = fields[key];
+      if (!check) return `${key}: unknown field`;
+      const e = check(record[key]);
+      if (e) return `${key}: ${e}`;
+    }
+    return null;
+  };
+  var ORDERS = ["XYZ", "YXZ", "ZXY", "ZYX", "YZX", "XZY"];
+  var TRANSFORM = {
+    position: tuple(3),
+    rotation: tuple(3),
+    rotationOrder: oneOf(ORDERS),
+    scale: (v) => typeof v === "number" ? num(v) : tuple(3)(v),
+    heading: num,
+    matrix: tuple(16)
+  };
+  var UV = object({ u0: num, v0: num, u1: num, v1: num }, ["u0", "v0", "u1", "v1"]);
+  var INSTANCE = object({ ...TRANSFORM, color });
+  var COMMON = {
+    ...TRANSFORM,
+    kind: str,
+    name: str,
+    part: str,
+    material: str,
+    color,
+    uv: UV,
+    instances: list(INSTANCE),
+    minDetail: range(0, 1, true),
+    tags: list(str)
+  };
+  var vec2 = tuple(2);
+  var BEVEL = (v) => v === false ? null : object({ thickness: num, size: num, offset: num, segments: int(1) })(v);
+  var KINDS = {
+    group: { fields: {} },
+    box: { fields: { size: tuple(3), segments: tuple(3, int(1)) } },
+    cylinder: { fields: { radiusTop: num, radiusBottom: num, height: num, radialSegments: int(1), heightSegments: int(1), openEnded: bool, thetaStart: num, thetaLength: num } },
+    cone: { fields: { radius: num, height: num, radialSegments: int(1), heightSegments: int(1), openEnded: bool, thetaStart: num, thetaLength: num } },
+    sphere: { fields: { radius: num, widthSegments: int(3), heightSegments: int(2), phiStart: num, phiLength: num, thetaStart: num, thetaLength: num } },
+    plane: { fields: { width: num, height: num, widthSegments: int(1), heightSegments: int(1) } },
+    circle: { fields: { radius: num, segments: int(3), thetaStart: num, thetaLength: num } },
+    ring: { fields: { innerRadius: num, outerRadius: num, thetaSegments: int(3), phiSegments: int(1), thetaStart: num, thetaLength: num } },
+    lathe: { fields: { points: list(vec2, 2), segments: int(1), phiStart: num, phiLength: num }, required: ["points"] },
+    torus: { fields: { radius: num, tube: num, radialSegments: int(1), tubularSegments: int(1), arc: num } },
+    extrude: {
+      fields: { shape: object({ outer: list(vec2, 3), holes: list(list(vec2, 3)) }, ["outer"]), depth: num, steps: int(1), bevel: BEVEL },
+      required: ["shape"]
+    },
+    difference: { fields: { size: tuple(3), subtract: list(object({ min: vec2, max: vec2 }, ["min", "max"])) }, required: ["size", "subtract"] },
+    mesh: {
+      fields: {
+        positions: (v) => list(num)(v) ?? (v.length % 3 === 0 ? null : "expected a multiple of 3 numbers"),
+        normals: list(num),
+        uvs: list(num),
+        indices: list(int(0))
+      },
+      required: ["positions"]
+    },
+    point: { fields: { data: () => null } },
+    custom: { fields: { generator: str, params: () => null }, required: ["generator"] }
+  };
+  function mergeTransformed(pieces) {
+    let total = 0;
+    for (const piece2 of pieces) total += piece2.indices ? piece2.indices.length : piece2.positions.length / 3;
+    const positions = new Float32Array(total * 3);
+    const normals = new Float32Array(total * 3);
+    const uvs = new Float32Array(total * 2);
+    let at = 0;
+    for (const piece2 of pieces) {
+      const e = piece2.matrix;
+      const nm = normalMatrix(e);
+      const count = piece2.indices ? piece2.indices.length : piece2.positions.length / 3;
+      const p = new Float32Array(count * 3);
+      const n = new Float32Array(count * 3);
+      for (let k = 0; k < count; k++) {
+        const i = piece2.indices ? piece2.indices[k] : k;
+        for (let c = 0; c < 3; c++) {
+          p[k * 3 + c] = piece2.positions[i * 3 + c];
+          if (piece2.normals) n[k * 3 + c] = piece2.normals[i * 3 + c];
+        }
+        if (piece2.uvs) {
+          uvs[(at + k) * 2] = piece2.uvs[i * 2];
+          uvs[(at + k) * 2 + 1] = piece2.uvs[i * 2 + 1];
+        }
+      }
+      for (let k = 0; k < count; k++) {
+        const q = transformPoint(e, p[k * 3], p[k * 3 + 1], p[k * 3 + 2]);
+        positions[(at + k) * 3] = q[0];
+        positions[(at + k) * 3 + 1] = q[1];
+        positions[(at + k) * 3 + 2] = q[2];
+        const x = n[k * 3];
+        const y = n[k * 3 + 1];
+        const z = n[k * 3 + 2];
+        const vx = nm[0] * x + nm[3] * y + nm[6] * z;
+        const vy = nm[1] * x + nm[4] * y + nm[7] * z;
+        const vz = nm[2] * x + nm[5] * y + nm[8] * z;
+        const s = 1 / (Math.sqrt(vx * vx + vy * vy + vz * vz) || 1);
+        normals[(at + k) * 3] = vx * s;
+        normals[(at + k) * 3 + 1] = vy * s;
+        normals[(at + k) * 3 + 2] = vz * s;
+      }
+      at += count;
+    }
+    return { positions, normals, uvs };
+  }
+
+  // ../game-shapes-three/dist/index.js
+  var isVisible = (object2) => {
+    for (let node = object2; node; node = node.parent) if (!node.visible) return false;
+    return true;
+  };
+  var plain = (attribute) => attribute !== void 0 && !attribute.isInterleavedBufferAttribute && attribute.array instanceof Float32Array && !attribute.normalized;
+  function piece(geometry, matrix) {
+    const position = geometry.getAttribute("position");
+    const normal = geometry.getAttribute("normal");
+    const uv = geometry.getAttribute("uv");
+    const ok = plain(position) && (normal === void 0 || plain(normal)) && (uv === void 0 || plain(uv)) && position.itemSize === 3 && (uv === void 0 || uv.itemSize === 2);
+    if (ok) {
+      return { positions: position.array, ...normal ? { normals: normal.array } : {}, ...uv ? { uvs: uv.array } : {}, indices: geometry.index ? geometry.index.array : null, matrix: matrix.elements };
+    }
+    const flat = geometry.index ? geometry.toNonIndexed() : geometry;
+    const read = (name, size) => {
+      const attribute = flat.getAttribute(name);
+      if (!attribute) return void 0;
+      const out = new Float32Array(attribute.count * size);
+      for (let i = 0; i < attribute.count; i++) for (let c = 0; c < size; c++) out[i * size + c] = c === 0 ? attribute.getX(i) : c === 1 ? attribute.getY(i) : attribute.getZ(i);
+      return out;
+    };
+    const positions = read("position", 3);
+    const normals = read("normal", 3);
+    const uvs = read("uv", 2);
+    if (flat !== geometry) flat.dispose();
+    return { positions, ...normals ? { normals } : {}, ...uvs ? { uvs } : {}, indices: null, matrix: matrix.elements };
+  }
+  function mergeByMaterial(THREE, root, space) {
+    const toSpace = space.matrixWorld.clone().invert();
+    const byMaterial = /* @__PURE__ */ new Map();
+    root.traverse((object2) => {
+      const mesh = object2;
+      if (!mesh.isMesh || Array.isArray(mesh.material) || !isVisible(mesh)) return;
+      const list2 = byMaterial.get(mesh.material) ?? [];
+      list2.push(piece(mesh.geometry, new THREE.Matrix4().multiplyMatrices(toSpace, mesh.matrixWorld)));
+      byMaterial.set(mesh.material, list2);
+    });
+    return [...byMaterial].map(([material, pieces]) => {
+      const merged = mergeTransformed(pieces);
+      const geometry = new THREE.BufferGeometry();
+      geometry.setAttribute("position", new THREE.BufferAttribute(merged.positions, 3));
+      geometry.setAttribute("normal", new THREE.BufferAttribute(merged.normals, 3));
+      geometry.setAttribute("uv", new THREE.BufferAttribute(merged.uvs, 2));
+      const mesh = new THREE.Mesh(geometry, material);
+      mesh.castShadow = false;
+      mesh.receiveShadow = true;
+      return mesh;
+    });
+  }
+
+  // ../game-props3d/dist/index.js
   function rng(seed) {
     let s = seed >>> 0;
     return () => {
@@ -567,10 +790,10 @@ var GameFloorplanThree = (() => {
       if (on) K.light(0, t - 0.15, 0, 16771256, 6, "ceiling_light");
     };
     B.pendant = (M, a) => {
-      const K = kit(M, a), t = K.ceiling(), { h } = K.dim("pendant"), ys = t - h, color = K.main(2763306);
+      const K = kit(M, a), t = K.ceiling(), { h } = K.dim("pendant"), ys = t - h, color2 = K.main(2763306);
       K.box("plain", 0, ys + 0.1, 0, 0.012, h - 0.1, 0.012, 1710618);
       K.cyl("plain", 0, t - 0.03, 0, 0.05, 0.03, 15262940);
-      K.cyl("plain", 0, ys, 0, 0.17, 0.14, color, 0, 0, "sphere");
+      K.cyl("plain", 0, ys, 0, 0.17, 0.14, color2, 0, 0, "sphere");
       K.cyl("emissive", 0, ys - 0.035, 0, 0.045, 0.09, 16769184, 0, 0, "sphere");
       if (M.light) K.light(0, ys - 0.1, 0, 16763008, 6, "pendant");
     };
@@ -939,9 +1162,9 @@ var GameFloorplanThree = (() => {
       K.box("plain", sx + 0.15, 0.012, sz + 0.05, 0.09, 0.07, 0.27, 2763306, 0.9);
     };
     B.fallen_chair = (M, a) => {
-      const g = Math.PI / 2, dy = 0.23, api = { box: (Mm, mat, x, y, z, w, h, d, color, ry, rx, rz) => {
+      const g = Math.PI / 2, dy = 0.23, api = { box: (Mm, mat, x, y, z, w, h, d, color2, ry, rx, rz) => {
         const cy = y + h / 2;
-        a.box(Mm, mat, -cy + 0, dy + x - h / 2 + 0 - 0, z, w, h, d, color, ry, rx, g + (rz || 0));
+        a.box(Mm, mat, -cy + 0, dy + x - h / 2 + 0 - 0, z, w, h, d, color2, ry, rx, g + (rz || 0));
       } };
       const K = kit(M, api), c = K.main(6965808);
       K.box("wood", 0, 0.44, 0, 0.42, 0.04, 0.42, c);
@@ -1031,20 +1254,20 @@ var GameFloorplanThree = (() => {
       K.plane("atlas_picture", 0, y + h / 2, d / 2 + 3e-3, w - 0.05, h - 0.05, 16777215, 0, 0, 0, A.mirror());
     };
     B.curtain = (M, a) => {
-      const K = kit(M, a), { w, h } = K.dim("curtain"), y = M.y != null && M.y > 0 ? M.y : 0.1, color = K.fabric(pick(K, [14208436, 10465470, 12953740, 14736592])), isOpen = M.open !== false, top = y + h;
+      const K = kit(M, a), { w, h } = K.dim("curtain"), y = M.y != null && M.y > 0 ? M.y : 0.1, color2 = K.fabric(pick(K, [14208436, 10465470, 12953740, 14736592])), isOpen = M.open !== false, top = y + h;
       K.box("metal", 0, top, 0, w + 0.1, 0.025, 0.025, K.metal(5918792));
       for (const s of [-1, 1]) K.cyl("metal", s * (w / 2 + 0.07), top - 0.02, 0, 0.03, 0.07, 5918792, 0, 0, "sphere");
       const pw = isOpen ? Math.min(0.5, w * 0.3) : w / 2 + 0.03, n = Math.max(4, Math.round(pw / 0.08));
       for (const s of [-1, 1]) for (let i = 0; i < n; i++) {
         const ux = isOpen ? s * (w / 2 + 0.03 - pw + (i + 0.5) * pw / n) : s * ((i + 0.5) * pw / n);
-        K.box("fabric", ux, y, i % 2 ? 0.025 : -0.01, pw / n * 1.15, h - 0.02, 0.02, i % 2 ? shade(color, 0.9) : color);
+        K.box("fabric", ux, y, i % 2 ? 0.025 : -0.01, pw / n * 1.15, h - 0.02, 0.02, i % 2 ? shade(color2, 0.9) : color2);
       }
-      if (isOpen) for (const s of [-1, 1]) K.box("fabric", s * (w / 2 - pw * 0.25), y + h * 0.4, 0.04, pw * 0.5, 0.05, 0.02, shade(color, 0.7));
+      if (isOpen) for (const s of [-1, 1]) K.box("fabric", s * (w / 2 - pw * 0.25), y + h * 0.4, 0.04, pw * 0.5, 0.05, 0.02, shade(color2, 0.7));
     };
     B.blinds = (M, a) => {
-      const K = kit(M, a), { w, h } = K.dim("blinds"), y = M.y || 1, retract = M.retracted != null ? M.retracted : 0.15, isWood = M.variant === "wood", color = isWood ? K.wood(10123858) : K.color("wall_living", 15262420), mat = isWood ? "wood" : "plain", yb = y + h * retract, n = Math.floor((y + h - yb) / 0.055);
+      const K = kit(M, a), { w, h } = K.dim("blinds"), y = M.y || 1, retract = M.retracted != null ? M.retracted : 0.15, isWood = M.variant === "wood", color2 = isWood ? K.wood(10123858) : K.color("wall_living", 15262420), mat = isWood ? "wood" : "plain", yb = y + h * retract, n = Math.floor((y + h - yb) / 0.055);
       K.box("plain", 0, y + h - 0.05, 0, w, 0.05, 0.06, 14473424);
-      for (let i = 0; i < n; i++) K.box(mat, 0, y + h - 0.06 - (i + 1) * 0.055, 0, w - 0.05, 0.01, 0.035, color, 0, 0.3);
+      for (let i = 0; i < n; i++) K.box(mat, 0, y + h - 0.06 - (i + 1) * 0.055, 0, w - 0.05, 0.01, 0.035, color2, 0, 0.3);
       for (const s of [-1, 1]) K.box("plain", s * (w / 2 - 0.05), yb, 0.02, 8e-3, y + h - 0.05 - yb, 8e-3, 12104876);
       K.box("plain", 0, yb - 0.02, 0, w - 0.03, 0.025, 0.04, 14473424);
     };
@@ -1337,13 +1560,13 @@ var GameFloorplanThree = (() => {
       const size = o.size || A.size(kind);
       const nv = A.variants(kind);
       const y = o.y != null ? o.y : HEIGHTS[kind] || 0.03;
-      const color = o.color != null ? hex(o.color) : 16777215;
+      const color2 = o.color != null ? hex(o.color) : 16777215;
       const poly = o.poly || M.poly;
       const sd = seedOf(M);
       const rnd = rng(sd);
       const tint = () => {
         const v = 0.93 + rnd() * 0.07;
-        return mix(0, color, v);
+        return mix(0, color2, v);
       };
       const quad = (cx, cz, qw, qd, uv) => api.plane(M, "atlas_floor", cx, y, cz, qw, qd, tint(), 0, -Math.PI / 2, 0, uv);
       if (!poly) {
@@ -1393,13 +1616,13 @@ var GameFloorplanThree = (() => {
       M,
       api,
       rnd: rng(seedOf(M)),
-      box: (material, x, y, z, w, h, d, color, ry, rx, rz) => api.box(M, material, x, y, z, w, h, d, hex(color), ry || 0, rx || 0, rz || 0),
-      cyl: (material, x, y, z, r, h, color, rx, rz, shape) => api.cylinder(M, material, x, y, z, r, h, hex(color), rx || 0, rz || 0, shape),
-      leaf: (x, y, z, w, h, color, ry, rx) => api.leaf(M, x, y, z, w, h, hex(color), ry || 0, rx || 0),
-      plane: (material, x, y, z, w, h, color, ry, rx, rz, uv) => api.plane(M, material, x, y, z, w, h, hex(color), ry || 0, rx || 0, rz || 0, uv),
-      light: (x, y, z, color, range, kind) => {
-        if (api.light) api.light(M, x, y, z, hex(color), range, kind);
-        else emit("light", { M, x, y, z, color: hex(color), range, kind });
+      box: (material, x, y, z, w, h, d, color2, ry, rx, rz) => api.box(M, material, x, y, z, w, h, d, hex(color2), ry || 0, rx || 0, rz || 0),
+      cyl: (material, x, y, z, r, h, color2, rx, rz, shape) => api.cylinder(M, material, x, y, z, r, h, hex(color2), rx || 0, rz || 0, shape),
+      leaf: (x, y, z, w, h, color2, ry, rx) => api.leaf(M, x, y, z, w, h, hex(color2), ry || 0, rx || 0),
+      plane: (material, x, y, z, w, h, color2, ry, rx, rz, uv) => api.plane(M, material, x, y, z, w, h, hex(color2), ry || 0, rx || 0, rz || 0, uv),
+      light: (x, y, z, color2, range2, kind) => {
+        if (api.light) api.light(M, x, y, z, hex(color2), range2, kind);
+        else emit("light", { M, x, y, z, color: hex(color2), range: range2, kind });
       },
       // colours: role in the house palette (M.palette) or the default; main = M.color
       color: (name, fallback) => role(name) ?? hex(fallback),
@@ -1414,10 +1637,10 @@ var GameFloorplanThree = (() => {
       },
       ceiling: () => M.ceiling || 2.9,
       // long tilted box: starts at (x, y, z) and follows u = (0, sin a, -cos a) for L meters
-      ramp(material, x, y, z, w, t, L, color, alpha) {
+      ramp(material, x, y, z, w, t, L, color2, alpha) {
         const cy = y + Math.sin(alpha) * L / 2;
         const cz = z - Math.cos(alpha) * L / 2;
-        K.box(material, x, cy - t / 2, cz, w, t, L, color, 0, alpha + Math.PI, 0);
+        K.box(material, x, cy - t / 2, cz, w, t, L, color2, 0, alpha + Math.PI, 0);
       }
     };
     return K;
@@ -1598,19 +1821,19 @@ var GameFloorplanThree = (() => {
     for (const key in owner) if (!skip.includes(key)) walk(owner[key], 0);
     return found;
   };
-  var isVisibleInTree = (object) => {
-    for (let node = object; node; node = node.parent) if (!node.visible) return false;
+  var isVisibleInTree = (object2) => {
+    for (let node = object2; node; node = node.parent) if (!node.visible) return false;
     return true;
   };
   var createNodeSkin = (THREE, root, options = {}) => {
     const referenced = new Set(options.nodes ?? []);
     const nodes = [];
     const indexOf = /* @__PURE__ */ new Map();
-    root.traverse((object) => {
-      const mesh2 = object;
-      if (!mesh2.isMesh || object.children.length > 0 || referenced.has(object)) {
-        indexOf.set(object, nodes.length);
-        nodes.push(object);
+    root.traverse((object2) => {
+      const mesh2 = object2;
+      if (!mesh2.isMesh || object2.children.length > 0 || referenced.has(object2)) {
+        indexOf.set(object2, nodes.length);
+        nodes.push(object2);
       }
     });
     const positions = [];
@@ -1619,7 +1842,7 @@ var GameFloorplanThree = (() => {
     const surfaces = [];
     const nodeIndices = [];
     const samples = /* @__PURE__ */ new Map();
-    const color = new THREE.Color();
+    const color2 = new THREE.Color();
     const vertex = new THREE.Vector3();
     const normal = new THREE.Vector3();
     const sampleOf = (texture) => {
@@ -1633,22 +1856,22 @@ var GameFloorplanThree = (() => {
       samples.set(texture, sample);
       return sample;
     };
-    root.traverse((object) => {
-      const mesh2 = object;
-      if (!mesh2.isMesh || !isVisibleInTree(object)) return;
+    root.traverse((object2) => {
+      const mesh2 = object2;
+      if (!mesh2.isMesh || !isVisibleInTree(object2)) return;
       const material2 = Array.isArray(mesh2.material) ? mesh2.material[0] : mesh2.material;
       const geometry2 = mesh2.geometry;
       const position = geometry2.attributes.position;
       const normalAttribute = geometry2.attributes.normal;
       const uv = geometry2.attributes.uv;
       const matrix = new THREE.Matrix4();
-      let nodeIndex = indexOf.get(object);
+      let nodeIndex = indexOf.get(object2);
       if (nodeIndex === void 0) {
-        nodeIndex = indexOf.get(object.parent) ?? 0;
-        object.updateMatrix();
-        matrix.copy(object.matrix);
+        nodeIndex = indexOf.get(object2.parent) ?? 0;
+        object2.updateMatrix();
+        matrix.copy(object2.matrix);
       }
-      const normalMatrix = new THREE.Matrix3().getNormalMatrix(matrix);
+      const normalMatrix2 = new THREE.Matrix3().getNormalMatrix(matrix);
       const sample = material2.map ? sampleOf(material2.map) : void 0;
       const emissive = material2.emissive ? (material2.emissive.r + material2.emissive.g + material2.emissive.b) * (material2.emissiveIntensity ?? 1) : 0;
       const index = geometry2.index ? geometry2.index.array : null;
@@ -1657,10 +1880,10 @@ var GameFloorplanThree = (() => {
         const at = index ? index[item] : item;
         vertex.fromBufferAttribute(position, at).applyMatrix4(matrix);
         positions.push(vertex.x, vertex.y, vertex.z);
-        if (normalAttribute) normal.fromBufferAttribute(normalAttribute, at).applyMatrix3(normalMatrix).normalize();
+        if (normalAttribute) normal.fromBufferAttribute(normalAttribute, at).applyMatrix3(normalMatrix2).normalize();
         else normal.set(0, 1, 0);
         normals.push(normal.x, normal.y, normal.z);
-        color.copy(material2.color || color.set(1, 1, 1)).convertLinearToSRGB();
+        color2.copy(material2.color || color2.set(1, 1, 1)).convertLinearToSRGB();
         if (sample && uv && material2.map) {
           const repeat = material2.map.repeat;
           const u = (uv.getX(at) * repeat.x % 1 + 1) % 1;
@@ -1668,10 +1891,10 @@ var GameFloorplanThree = (() => {
           const pixelX = Math.min(sample.width - 1, u * sample.width | 0);
           const pixelY = Math.min(sample.height - 1, (1 - v) * sample.height | 0);
           const offset = (pixelY * sample.width + pixelX) * 4;
-          color.multiply(new THREE.Color().setRGB(sample.data[offset] / 255, sample.data[offset + 1] / 255, sample.data[offset + 2] / 255, THREE.SRGBColorSpace));
+          color2.multiply(new THREE.Color().setRGB(sample.data[offset] / 255, sample.data[offset + 1] / 255, sample.data[offset + 2] / 255, THREE.SRGBColorSpace));
         }
-        if (emissive > 0.3) color.lerp(material2.emissive, 0.7);
-        tints.push(color.r, color.g, color.b);
+        if (emissive > 0.3) color2.lerp(material2.emissive, 0.7);
+        tints.push(color2.r, color2.g, color2.b);
         surfaces.push(material2.roughness ?? 0.8, material2.metalness ?? 0, emissive > 0.3 ? 1 : 0);
         nodeIndices.push(nodeIndex);
       }
@@ -1718,64 +1941,120 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
   function createRecorder(options = {}) {
     const primitives = [];
     const api = {
-      box: (M, material, x, y, z, w, h, d, color, ry, rx, rz) => void primitives.push({ kind: "box", M, material, x, y, z, w, h, d, color, ry, rx, rz }),
-      cylinder: (M, material, x, y, z, r, h, color, rx, rz, shape) => void primitives.push({ kind: "cylinder", M, material, x, y, z, r, h, color, rx, rz, shape }),
-      leaf: (M, x, y, z, w, h, color, ry, rx) => void primitives.push({ kind: "leaf", M, x, y, z, w, h, color, ry, rx }),
-      plane: (M, material, x, y, z, w, h, color, ry, rx, rz, uv) => void primitives.push({ kind: "plane", M, material, x, y, z, w, h, color, ry, rx, rz, uv })
+      box: (M, material, x, y, z, w, h, d, color2, ry, rx, rz) => void primitives.push({ kind: "box", M, material, x, y, z, w, h, d, color: color2, ry, rx, rz }),
+      cylinder: (M, material, x, y, z, r, h, color2, rx, rz, shape) => void primitives.push({ kind: "cylinder", M, material, x, y, z, r, h, color: color2, rx, rz, shape }),
+      leaf: (M, x, y, z, w, h, color2, ry, rx) => void primitives.push({ kind: "leaf", M, x, y, z, w, h, color: color2, ry, rx }),
+      plane: (M, material, x, y, z, w, h, color2, ry, rx, rz, uv) => void primitives.push({ kind: "plane", M, material, x, y, z, w, h, color: color2, ry, rx, rz, uv })
     };
     if (options.light !== false) {
-      api.light = (M, x, y, z, color, range, lightKind) => void primitives.push({ kind: "light", M, x, y, z, color, range, lightKind });
+      api.light = (M, x, y, z, color2, range2, lightKind) => void primitives.push({ kind: "light", M, x, y, z, color: color2, range: range2, lightKind });
     }
     return { api, primitives };
   }
-  var ATTRIBUTES = ["position", "normal", "uv"];
-  var isVisible = (object) => {
-    for (let node = object; node; node = node.parent) if (!node.visible) return false;
-    return true;
-  };
-  var bake = (THREE, mesh, matrix) => {
-    const source = mesh.geometry.index ? mesh.geometry.toNonIndexed() : mesh.geometry.clone();
-    const baked = new THREE.BufferGeometry();
-    const count = source.getAttribute("position").count;
-    for (const name of ATTRIBUTES) {
-      const attribute = source.getAttribute(name);
-      baked.setAttribute(name, attribute ?? new THREE.BufferAttribute(new Float32Array(count * (name === "uv" ? 2 : 3)), name === "uv" ? 2 : 3));
-    }
-    source.dispose();
-    return baked.applyMatrix4(matrix);
-  };
-  var join = (THREE, geometries) => {
-    const merged = new THREE.BufferGeometry();
-    for (const name of ATTRIBUTES) {
-      const size = (geometries[0]?.getAttribute(name)).itemSize;
-      const total = geometries.reduce((sum, geometry) => sum + geometry.getAttribute(name).count, 0);
-      const array = new Float32Array(total * size);
-      let offset = 0;
-      for (const geometry of geometries) {
-        array.set(geometry.getAttribute(name).array, offset);
-        offset += geometry.getAttribute(name).count * size;
-      }
-      merged.setAttribute(name, new THREE.BufferAttribute(array, size));
-    }
-    return merged;
-  };
-  function mergeByMaterial(THREE, root, space) {
-    const toSpace = space.matrixWorld.clone().invert();
-    const byMaterial = /* @__PURE__ */ new Map();
-    root.traverse((object) => {
-      const mesh = object;
-      if (!mesh.isMesh || Array.isArray(mesh.material) || !isVisible(mesh)) return;
-      const list = byMaterial.get(mesh.material) ?? [];
-      list.push(bake(THREE, mesh, new THREE.Matrix4().multiplyMatrices(toSpace, mesh.matrixWorld)));
-      byMaterial.set(mesh.material, list);
-    });
-    return [...byMaterial].map(([material, geometries]) => {
-      const merged = new THREE.Mesh(join(THREE, geometries), material);
-      for (const geometry of geometries) geometry.dispose();
-      merged.castShadow = false;
-      merged.receiveShadow = true;
-      return merged;
-    });
+  var LEAF = (() => {
+    const f = [0, 0, 0, -0.5, 0.4, 0, 0.5, 0.4, 0, 0, 1, 0];
+    const positions = [];
+    const normals = [];
+    const uvs = [];
+    const indices = [];
+    for (const side of [1, -1]) {
+      const base = positions.length / 3;
+      for (let i = 0; i < 4; i++) {
+        positions.push(f[i * 3], f[i * 3 + 1], f[i * 3 + 2]);
+        normals.push(0, 0, side);
+        uvs.push(f[i * 3] + 0.5, f[i * 3 + 1]);
+      }
+      if (side === 1) indices.push(base, base + 2, base + 1, base + 1, base + 2, base + 3);
+      else indices.push(base, base + 1, base + 2, base + 1, base + 3, base + 2);
+    }
+    return { positions, normals, uvs, indices };
+  })();
+  function createShapeRecorder(options = {}) {
+    const cyl = options.cylinderSegments ?? 12;
+    const hex2 = options.hexSegments ?? 6;
+    const [sphereW, sphereH] = options.sphereSegments ?? [12, 8];
+    const root = [];
+    const parts = [];
+    const partChildren = /* @__PURE__ */ new Map();
+    let current = root;
+    let lastFrame = null;
+    const into = (M) => {
+      const x = M?.x ?? 0;
+      const z = M?.z ?? 0;
+      const ry = M?.ry ?? 0;
+      const last = lastFrame;
+      if (last && last.list === current && current[current.length - 1] === last.group && Object.is(last.x, x) && Object.is(last.z, z) && Object.is(last.ry, ry)) return last.group.children;
+      const group = { kind: "group", position: [x, 0, z], heading: ry, children: [] };
+      current.push(group);
+      lastFrame = { list: current, group, x, z, ry };
+      return group.children;
+    };
+    const api = {
+      box(M, material, x, y, z, w, h, d, color2, ry, rx, rz) {
+        into(M).push({ kind: "box", material, color: color2, position: [x, y + h / 2, z], rotation: [rx, ry, rz], rotationOrder: "YXZ", scale: [w, h, d] });
+      },
+      cylinder(M, material, x, y, z, r, h, color2, rx, rz, shape) {
+        const tilted = rx !== 0 || rz !== 0;
+        const cy = shape === "sphere" ? y + h / 2 : tilted ? y : y + h / 2;
+        const sy = shape === "sphere" ? h / 2 : h;
+        const place = { material, color: color2, position: [x, cy, z], rotation: [rx, 0, rz], rotationOrder: "YXZ", scale: [r, sy, r] };
+        const list2 = into(M);
+        switch (shape) {
+          case "cyl6":
+            list2.push({ kind: "cylinder", radiusTop: 1, radiusBottom: 1, height: 1, radialSegments: hex2, ...place });
+            break;
+          case "cone":
+            list2.push({ kind: "cylinder", radiusTop: 0, radiusBottom: 1, height: 1, radialSegments: cyl, ...place });
+            break;
+          case "sphere":
+            list2.push({ kind: "sphere", radius: 1, widthSegments: sphereW, heightSegments: sphereH, ...place });
+            break;
+          default:
+            list2.push({ kind: "cylinder", radiusTop: 1, radiusBottom: 1, height: 1, radialSegments: cyl, ...place });
+        }
+      },
+      leaf(M, x, y, z, w, h, color2, ry, rx) {
+        into(M).push({ kind: "mesh", ...LEAF, material: "plant", color: color2, position: [x, y, z], rotation: [rx, ry, 0], rotationOrder: "YXZ", scale: [w, h, 1] });
+      },
+      plane(M, material, x, y, z, w, h, color2, ry, rx, rz, uv) {
+        into(M).push({
+          kind: "plane",
+          width: 1,
+          height: 1,
+          material,
+          color: color2,
+          position: [x, y, z],
+          rotation: [rx, ry, rz],
+          rotationOrder: "YXZ",
+          scale: [w, h, 1],
+          ...uv ? { uv: { u0: uv.u0, v0: uv.v0, u1: uv.u1, v1: uv.v1 } } : {}
+        });
+      },
+      light(M, x, y, z, color2, range2, kind) {
+        into(M).push({ kind: "point", position: [x, y, z], data: { light: true, color: color2, range: range2, kind } });
+      },
+      part(id, pivot, ry, draw) {
+        let children = partChildren.get(id);
+        if (!children) {
+          children = [];
+          partChildren.set(id, children);
+          parts.push({ id, pivot: [pivot[0], pivot[1], pivot[2]], ry });
+          current.push({ kind: "group", part: id, position: [pivot[0], pivot[1], pivot[2]], rotation: [0, ry, 0], children });
+        }
+        const outer = current;
+        current = children;
+        try {
+          draw();
+        } finally {
+          current = outer;
+        }
+      }
+    };
+    return {
+      api,
+      parts,
+      schema: () => ({ version: 1, ...options.name !== void 0 ? { name: options.name } : {}, root: { kind: "group", children: root } })
+    };
   }
 
   // src/locale.ts
@@ -1795,7 +2074,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     "what.fridge": "fridge",
     "what.pantry": "pantry",
     "what.cabinet": "cabinet",
-    "warn.interactablesIncomplete": "floorplan-three: cfg.interactives is incomplete (GameInteractables, GameInteractablesHousehold, GameInteractablesThree, adapter)",
+    "warn.interactablesIncomplete": "floorplan-three: cfg.interactives is incomplete (GameInteractables, GameInteractablesHousehold, GameInteractablesThree)",
     "message.locked": "Locked.",
     "message.boarded": "Locked: the door is boarded up.",
     "message.pickedUp": "Picked up: {name}{qty}",
@@ -1820,7 +2099,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     "what.fridge": "geladeira",
     "what.pantry": "despensa",
     "what.cabinet": "arm\xE1rio",
-    "warn.interactablesIncomplete": "floorplan-three: cfg.interactives incompleto (GameInteractables, GameInteractablesHousehold, GameInteractablesThree, adapter)",
+    "warn.interactablesIncomplete": "floorplan-three: cfg.interactives incompleto (GameInteractables, GameInteractablesHousehold, GameInteractablesThree)",
     "message.locked": "Trancada.",
     "message.boarded": "Trancada: a porta est\xE1 bloqueada com t\xE1buas.",
     "message.pickedUp": "Pegou: {name}{qty}",
@@ -1987,7 +2266,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       _col.setHex(h);
       return [_col.r, _col.g, _col.b];
     };
-    function put(mat, geo, px, py, pz, q, sx, sy, sz, color, uvr) {
+    function put(mat, geo, px, py, pz, q, sx, sy, sz, color2, uvr) {
       {
         const O = cursor.org, RY = cursor.ry;
         if (RY) {
@@ -2009,7 +2288,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       const x = q.x, y = q.y, z = q.z, w = q.w, x2 = x + x, y2 = y + y, z2 = z + z;
       const xx = x * x2, xy = x * y2, xz = x * z2, yy = y * y2, yz = y * z2, zz = z * z2, wx = w * x2, wy = w * y2, wz = w * z2;
       const m00 = 1 - (yy + zz), m01 = xy - wz, m02 = xz + wy, m10 = xy + wz, m11 = 1 - (xx + zz), m12 = yz - wx, m20 = xz - wy, m21 = yz + wx, m22 = 1 - (xx + yy);
-      const [cr, cg, cb] = rgbOf(color), scale = UV_SCALE[mat], b = A.nv;
+      const [cr, cg, cb] = rgbOf(color2), scale = UV_SCALE[mat], b = A.nv;
       for (let k = 0; k < G.nv; k++) {
         const lx = G.p[k * 3] * sx, ly = G.p[k * 3 + 1] * sy, lz = G.p[k * 3 + 2] * sz;
         const wx_ = m00 * lx + m01 * ly + m02 * lz + px, wy_ = m10 * lx + m11 * ly + m12 * lz + py, wz_ = m20 * lx + m21 * ly + m22 * lz + pz;
@@ -2064,21 +2343,21 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       A.nv += G.nv;
       A.ni += G.i ? G.i.length : G.nv;
     }
-    function boxC(mat, cx, cy, cz, sx, sy, sz, color, rx = 0, ry = 0, rz = 0, uvr) {
+    function boxC(mat, cx, cy, cz, sx, sy, sz, color2, rx = 0, ry = 0, rz = 0, uvr) {
       if (rx || ry || rz) _q.setFromEuler(_e.set(rx, ry, rz, "YXZ"));
       else _q.identity();
-      put(mat, "box", cx, cy, cz, _q, sx, sy, sz, color, uvr);
+      put(mat, "box", cx, cy, cz, _q, sx, sy, sz, color2, uvr);
     }
-    function bxBase(mat, x0, y0, z0, x1, y1, z1, color) {
+    function bxBase(mat, x0, y0, z0, x1, y1, z1, color2) {
       if (x1 - x0 < 1e-4 || y1 - y0 < 1e-4 || z1 - z0 < 1e-4) return;
       _q.identity();
-      put(mat, "box", (x0 + x1) / 2, (y0 + y1) / 2, (z0 + z1) / 2, _q, x1 - x0, y1 - y0, z1 - z0, color);
+      put(mat, "box", (x0 + x1) / 2, (y0 + y1) / 2, (z0 + z1) / 2, _q, x1 - x0, y1 - y0, z1 - z0, color2);
     }
-    function cylBase(mat, x, y, z, r, h, color, seg = "cyl") {
+    function cylBase(mat, x, y, z, r, h, color2, seg = "cyl") {
       _q.identity();
-      put(mat, seg, x, y + h / 2, z, _q, r * 2, h, r * 2, color);
+      put(mat, seg, x, y + h / 2, z, _q, r * 2, h, r * 2, color2);
     }
-    function polyFace(mat, pts, color, hint) {
+    function polyFace(mat, pts, color2, hint) {
       const A = accFor(mat), n = pts.length, O = cursor.org, RY = cursor.ry;
       A.ensure(n, (n - 2) * 3);
       if (RY) {
@@ -2105,7 +2384,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         nz = -nz;
         [a, b] = [pts[0], pts[1]];
       }
-      const [cr, cg, cb] = rgbOf(color), scale = UV_SCALE[mat] || 1, base = A.nv;
+      const [cr, cg, cb] = rgbOf(color2), scale = UV_SCALE[mat] || 1, base = A.nv;
       let e1x = b[0] - a[0], e1y = b[1] - a[1], e1z = b[2] - a[2];
       const l1 = Math.hypot(e1x, e1y, e1z) || 1;
       e1x /= l1;
@@ -2564,16 +2843,16 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       const R = shared.ctx.r, F = R.facade;
       if (id === "outside" || !shared.ctx.roomById[id]) {
         const ac = F.finish;
-        let mat = "plaster", color = shared.ctx.colors.facade;
+        let mat = "plaster", color2 = shared.ctx.colors.facade;
         if (ac === "roughcast") mat = "roughcast";
         else if (ac === "exposed_block") {
           mat = "block";
-          color = 12894392;
+          color2 = 12894392;
         } else if (ac === "partial_plaster" && !frontLine) {
           mat = "block";
-          color = 12894392;
+          color2 = 12894392;
         }
-        return { color, mat, exterior: true };
+        return { color: color2, mat, exterior: true };
       }
       return { color: wallColor(shared.ctx.roomById[id]), mat: "plaster", exterior: false };
     }
@@ -2683,7 +2962,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
           wallBox(alongU, L, a, b, y0 + dH, y0 + effectiveHeight(f, wallHeight), th, lL.color, lH.color, lL.mat, lH.mat);
           cursor.pc = null;
         }
-        const fb = (u0, y_0, u1, y_1, tt = th + 0.02, color = frame) => alongU ? bx("wood", u0, y0 + y_0, L - tt / 2, u1, y0 + y_1, L + tt / 2, color) : bx("wood", L - tt / 2, y0 + y_0, u0, L + tt / 2, y0 + y_1, u1, color);
+        const fb = (u0, y_0, u1, y_1, tt = th + 0.02, color2 = frame) => alongU ? bx("wood", u0, y0 + y_0, L - tt / 2, u1, y0 + y_1, L + tt / 2, color2) : bx("wood", L - tt / 2, y0 + y_0, u0, L + tt / 2, y0 + y_1, u1, color2);
         const jw = 0.05;
         cursor.pc = pieceRecord("jamb:" + p.id, "wood_hard", null, { floor: f });
         fb(a, 0, a + jw, visH);
@@ -2697,7 +2976,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
           if (cL && cL.id === p.opensTo) sw = -1;
           else if (cH && cH.id === p.opensTo) sw = 1;
         }
-        const leaf = (u0, u1, y_0, y_1, tt, color, mat = "wood") => alongU ? bx(mat, u0, y0 + y_0, L - tt / 2, u1, y0 + y_1, L + tt / 2, color) : bx(mat, L - tt / 2, y0 + y_0, u0, L + tt / 2, y0 + y_1, u1, color);
+        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);
@@ -2706,19 +2985,19 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         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);
         fo.col = colR;
-        const leafBox = (hu, d0, d1, y_0, y_1, tt, color, mat) => alongU ? bx(mat, d0, y_0, -tt / 2, d1, y_1, tt / 2, color) : bx(mat, -tt / 2, y_0, d0, tt / 2, y_1, d1, color);
+        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) => {
           cursor.group = "dyn:" + p.id + ":" + k;
           fo.groups.push({ name: cursor.group, pos: alongU ? [hu, topY != null ? y0 + topY : y0, L] : [L, topY != null ? y0 + topY : y0, hu] });
         };
         if (p.model === "steel") {
-          const light = [14276044, 13223615, 14999766], pal = ((R.seed | 0) + p.id.length * 7) % 4, color = pal === 3 ? wood : light[pal], mid = (a + b) / 2;
+          const light = [14276044, 13223615, 14999766], pal = ((R.seed | 0) + p.id.length * 7) % 4, color2 = pal === 3 ? wood : light[pal], mid = (a + b) / 2;
           newGroup(0, mid, visH);
-          const la = a + jw - mid, lb = b - jw - mid, nSec = Math.max(4, Math.round(visH / 0.5)), hs = visH / nSec, grv = sh(color, 0.55);
-          leafBox(0, la, lb, -visH, 0, 0.05, color, "metal");
+          const la = a + jw - mid, lb = b - jw - mid, nSec = Math.max(4, Math.round(visH / 0.5)), hs = visH / nSec, grv = sh(color2, 0.55);
+          leafBox(0, la, lb, -visH, 0, 0.05, color2, "metal");
           for (let k = 1; k < nSec; k++) leafBox(0, la, lb, -k * hs - 0.012, -k * hs + 0.012, 0.07, grv, "metal");
           const np = Math.max(2, Math.round((lb - la) / 0.8)), pw = (lb - la) / np;
-          for (let k = 0; k < nSec; k++) for (let i = 0; i < np; i++) leafBox(0, la + i * pw + 0.07, la + (i + 1) * pw - 0.07, -(k + 1) * hs + 0.07, -k * hs - 0.07, 0.062, sh(color, k % 2 ? 0.93 : 1.06), "metal");
+          for (let k = 0; k < nSec; k++) for (let i = 0; i < np; i++) leafBox(0, la + i * pw + 0.07, la + (i + 1) * pw - 0.07, -(k + 1) * hs + 0.07, -k * hs - 0.07, 0.062, sh(color2, k % 2 ? 0.93 : 1.06), "metal");
           for (let i = 0; i < np; i++) leafBox(0, la + i * pw + 0.14, la + (i + 1) * pw - 0.14, -hs + 0.12, -0.12, 0.072, 5924464, "glass");
           leafBox(0, -0.1, 0.1, -visH + 0.5, -visH + 0.55, 0.085, 3815998, "metal");
           fo.minScale = Math.min(1, 0.28 / visH);
@@ -2726,13 +3005,13 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         } else {
           const nf = p.model === "double" ? 2 : 1, aa = a + jw, bb = b - jw;
           for (let k = 0; k < nf; k++) {
-            const u0 = nf === 2 ? k ? (aa + bb) / 2 : aa : aa, u1 = nf === 2 ? k ? bb : (aa + bb) / 2 : bb, color = p.exterior ? extC : wood;
+            const u0 = nf === 2 ? k ? (aa + bb) / 2 : aa : aa, u1 = nf === 2 ? k ? bb : (aa + bb) / 2 : bb, color2 = p.exterior ? extC : wood;
             const hingeAt = nf === 2 ? k ? u1 : u0 : p.hinge === "end" ? u1 : u0, dir = hingeAt === u0 ? 1 : -1, len = u1 - u0;
             newGroup(k, hingeAt);
             const d0 = dir > 0 ? 5e-3 : -len + 5e-3, d1 = dir > 0 ? len - 5e-3 : -5e-3;
-            leafBox(hingeAt, d0, d1, 0, visH, 0.04, color, PMAT);
+            leafBox(hingeAt, d0, d1, 0, visH, 0.04, color2, PMAT);
             {
-              const e0 = Math.min(d0, d1) + 0.1, e1 = Math.max(d0, d1) - 0.1, pc = sh(color, 0.82);
+              const e0 = Math.min(d0, d1) + 0.1, e1 = Math.max(d0, d1) - 0.1, pc = sh(color2, 0.82);
               if (e1 - e0 > 0.2 && visH > 1.2) {
                 leafBox(hingeAt, e0, e1, 0.15, visH * 0.45, 0.055, pc, PMAT);
                 leafBox(hingeAt, e0, e1, visH * 0.5, visH - 0.15, 0.055, pc, PMAT);
@@ -2769,9 +3048,9 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         if (p.blocked) {
           part("window_boards", [0, 0, 0], () => {
             const rb = rngString(SEED() + "|" + seedKey(p.id) + "|tabua"), cx0 = alongU ? p.at : L, cz0 = alongU ? L : p.at, nT = Math.max(4, Math.round((visH - 0.3) / 0.3)), Lg = p.width + 0.34, WOODS = [8017460, 7031338, 9071172, 6177320, 7559746];
-            const puts = (along, y, off, comp, alt, thickness, color, tilt) => {
+            const puts = (along, y, off, comp, alt, thickness, color2, tilt) => {
               const x = alongU ? along : L + off, z = alongU ? L + off : along;
-              boxC("wood", x, y0 + y, z, comp, alt, thickness, color, 0, alongU ? 0 : K.PE, tilt);
+              boxC("wood", x, y0 + y, z, comp, alt, thickness, color2, 0, alongU ? 0 : K.PE, tilt);
             };
             const nailColor = (along, y, off) => {
               const x = alongU ? along : L + off, z = alongU ? L + off : along;
@@ -2784,8 +3063,8 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
                 puts(alongU ? cx0 : cz0, visH / 2, o1, Math.hypot(p.width + 0.2, visH - 0.4) + 0.1, 0.12, 0.028, sh(WOODS[rb() * 5 | 0], 0.85), a2);
               }
               for (let k = 0; k < nT; k++) {
-                const y = 0.18 + k * (visH - 0.4) / (nT - 1) + (rb() - 0.5) * 0.04, comp = Lg + (rb() - 0.5) * 0.12, tilt = (rb() - 0.5) * 0.05, alt = 0.13 + rb() * 0.03, c0 = alongU ? cx0 : cz0, color = WOODS[rb() * WOODS.length | 0];
-                puts(c0 + (rb() - 0.5) * 0.06, y, o2, comp, alt, 0.03, color, tilt);
+                const y = 0.18 + k * (visH - 0.4) / (nT - 1) + (rb() - 0.5) * 0.04, comp = Lg + (rb() - 0.5) * 0.12, tilt = (rb() - 0.5) * 0.05, alt = 0.13 + rb() * 0.03, c0 = alongU ? cx0 : cz0, color2 = WOODS[rb() * WOODS.length | 0];
+                puts(c0 + (rb() - 0.5) * 0.06, y, o2, comp, alt, 0.03, color2, tilt);
                 for (const e of [-1, 1]) {
                   nailColor(c0 + e * (comp / 2 - 0.07), y + Math.sin(tilt) * e * comp / 2, o2 + sd * 0.019);
                 }
@@ -2817,7 +3096,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
           yb = Math.min(yb, 1.2);
         }
         const wref = R.walls.find((w) => w.floor === f && w.axis === j.axis && Math.abs((alongU ? w.v0 : w.u0) - L) < EPS), th = wref ? wref.thickness || 0.15 : 0.15, t = 0.05, tt = th + 0.02;
-        const bar = (u0, y_0, u1, y_1, mat, color, tw = tt) => alongU ? bx(mat, u0, y0 + y_0, L - tw / 2, u1, y0 + y_1, L + tw / 2, color) : bx(mat, L - tw / 2, y0 + y_0, u0, L + tw / 2, y0 + y_1, u1, color);
+        const bar = (u0, y_0, u1, y_1, mat, color2, tw = tt) => alongU ? bx(mat, u0, y0 + y_0, L - tw / 2, u1, y0 + y_1, L + tw / 2, color2) : bx(mat, L - tw / 2, y0 + y_0, u0, L + tw / 2, y0 + y_1, u1, color2);
         cursor.pc = pieceRecord("window_frame:" + j.id, "aluminium", null, { floor: f });
         bar(a, ya, a + t, yb, "metal", fr);
         bar(b - t, ya, b, yb, "metal", fr);
@@ -2929,9 +3208,9 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         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 P = (lx, lz) => [m.x + lx * c + lz * s, m.z - lx * s + lz * c];
-        const boxL = (mat, lx, y, lz, w, h, d, color, rx = 0) => {
+        const boxL = (mat, lx, y, lz, w, h, d, color2, rx = 0) => {
           const [px, pz] = P(lx, lz);
-          boxC(mat, px, y, pz, w, h, d, color, rx, m.ry, 0);
+          boxC(mat, px, y, pz, w, h, d, color2, rx, m.ry, 0);
         };
         for (let i = 0; i < n; i++) {
           const top = (i + 1) * H / n, lz = m.d / 2 - (i + 0.5) * Dr / n;
@@ -3002,20 +3281,20 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         get A() {
           return api;
         },
-        b: (mat, x, y, z, w, h, d, color, ry, rx, rz) => api.box(M, mat, x, y0 + y, z, w, h, d, color, ry || 0, rx || 0, rz || 0),
-        c: (mat, x, y, z, r, h, color, seg) => api.cylinder(M, mat, x, y0 + y, z, r, h, color, 0, 0, seg),
-        e: (mat, x, y, z, r, h, color) => api.cylinder(M, mat, x, y0 + y - h / 2, z, r, h, color, 0, 0, "sphere"),
-        t(mat, p, q, r, color, seg) {
+        b: (mat, x, y, z, w, h, d, color2, ry, rx, rz) => api.box(M, mat, x, y0 + y, z, w, h, d, color2, ry || 0, rx || 0, rz || 0),
+        c: (mat, x, y, z, r, h, color2, seg) => api.cylinder(M, mat, x, y0 + y, z, r, h, color2, 0, 0, seg),
+        e: (mat, x, y, z, r, h, color2) => api.cylinder(M, mat, x, y0 + y - h / 2, z, r, h, color2, 0, 0, "sphere"),
+        t(mat, p, q, r, color2, seg) {
           const dx = q[0] - p[0], dy = q[1] - p[1], dz = q[2] - p[2], L = Math.hypot(dx, dy, dz);
           if (L < 1e-5) return;
           const nx = dx / L, ny = dy / L, nz = dz / L;
           if (Math.abs(nx) < 1e-4 && Math.abs(nz) < 1e-4) {
-            api.cylinder(M, mat, p[0], y0 + Math.min(p[1], q[1]), p[2], r, L, color, 0, 0, seg);
+            api.cylinder(M, mat, p[0], y0 + Math.min(p[1], q[1]), p[2], r, L, color2, 0, 0, seg);
             return;
           }
-          api.cylinder(M, mat, (p[0] + q[0]) / 2, y0 + (p[1] + q[1]) / 2, (p[2] + q[2]) / 2, r, L, color, Math.atan2(nz, ny), -Math.asin(nx), seg);
+          api.cylinder(M, mat, (p[0] + q[0]) / 2, y0 + (p[1] + q[1]) / 2, (p[2] + q[2]) / 2, r, L, color2, Math.atan2(nz, ny), -Math.asin(nx), seg);
         },
-        polyFace: (mat, pts, color, hint) => polyFace(mat, pts.map((p) => W(p[0], p[1], p[2])), color, hint && [hint[0] * c + hint[2] * s, hint[1], -hint[0] * s + hint[2] * c]),
+        polyFace: (mat, pts, color2, hint) => polyFace(mat, pts.map((p) => W(p[0], p[1], p[2])), color2, hint && [hint[0] * c + hint[2] * s, hint[1], -hint[0] * s + hint[2] * c]),
         part(type, lx, ly, lz, fn, meta) {
           if (type === "lamp" && String(cursor.group).startsWith("ix:light:")) {
             fn();
@@ -3056,28 +3335,28 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       return v < 0.28 ? "recessed" : v < 0.5 ? "track" : v < 0.75 ? social ? "pendant" : "recessed" : /living|dining|hall/.test(tp) ? "chandelier" : "recessed";
     }
     function ceilingLamp(M, A, type) {
-      const K2 = kit2(M, A, 0), t = M.ceiling || 2.8, color = colorTemperature(M), r = rngString(SEED() + "|" + seedKey(M.seed) + "|lz");
-      const id = "lamp_" + (M.seed || hashString(M.x + "," + M.z)), meta = { id, room: M.room, on: !!M.on, color, lightType: type, hidden: !M.on };
+      const K2 = kit2(M, A, 0), t = M.ceiling || 2.8, color2 = colorTemperature(M), r = rngString(SEED() + "|" + seedKey(M.seed) + "|lz");
+      const id = "lamp_" + (M.seed || hashString(M.x + "," + M.z)), meta = { id, room: M.room, on: !!M.on, color: color2, lightType: type, hidden: !M.on };
       const white = 16052972, offset = 15329247;
-      let yLight = t - 0.18, range = 6;
+      let yLight = t - 0.18, range2 = 6;
       const emitter = (fn) => K2.part("lamp", 0, t, 0, fn, meta);
       if (type === "bare") {
         K2.c("plain", 0, t - 0.03, 0, 0.05, 0.03, white);
         K2.c("metal", 0, t - 0.085, 0, 0.022, 0.055, 6974054);
         K2.c("plain", 0, t - 0.105, 0, 0.026, 0.02, 14209208);
         K2.e("plain", 0, t - 0.165, 0, 0.036, 0.085, 15987178);
-        emitter(() => K2.e("emissive", 0, t - 0.165, 0, 0.0385, 0.088, color));
+        emitter(() => K2.e("emissive", 0, t - 0.165, 0, 0.0385, 0.088, color2));
         yLight = t - 0.22;
-        range = 5.5;
+        range2 = 5.5;
       } else if (type === "round") {
         K2.c("plain", 0, t - 0.05, 0, 0.19, 0.05, white);
         K2.c("plain", 0, t - 0.07, 0, 0.165, 0.02, offset);
-        emitter(() => K2.c("emissive", 0, t - 0.073, 0, 0.1675, 0.023, color));
+        emitter(() => K2.c("emissive", 0, t - 0.073, 0, 0.1675, 0.023, color2));
         yLight = t - 0.2;
       } else if (type === "square") {
         K2.b("plain", 0, t - 0.05, 0, 0.36, 0.05, 0.36, white);
         K2.b("plain", 0, t - 0.07, 0, 0.3, 0.02, 0.3, offset);
-        emitter(() => K2.b("emissive", 0, t - 0.073, 0, 0.3025, 0.023, 0.3025, color));
+        emitter(() => K2.b("emissive", 0, t - 0.073, 0, 0.3025, 0.023, 0.3025, color2));
         yLight = t - 0.2;
       } else if (type === "recessed") {
         const o = 0.5;
@@ -3086,10 +3365,10 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
           K2.c("plain", x, t - 0.026, z, 0.05, 0.012, offset);
         }
         emitter(() => {
-          for (const [x, z] of [[-o, -o], [o, -o], [-o, o], [o, o]]) K2.c("emissive", x, t - 0.028, z, 0.0505, 0.014, color);
+          for (const [x, z] of [[-o, -o], [o, -o], [-o, o], [o, o]]) K2.c("emissive", x, t - 0.028, z, 0.0505, 0.014, color2);
         });
         yLight = t - 0.3;
-        range = 6.5;
+        range2 = 6.5;
       } else if (type === "track") {
         const len = 1.1, angle = r() < 0.5 ? 0 : Math.PI / 2, c = Math.cos(angle), s = Math.sin(angle);
         K2.b("metal", 0, t - 0.03, 0, angle ? 0.035 : len, 0.03, angle ? len : 0.035, 2763308);
@@ -3105,16 +3384,16 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
           for (const [q, d] of cab) K2.t("emissive", [q[0] - d[0] * 3e-3, q[1] - d[1] * 3e-3, q[2] - d[2] * 3e-3], [q[0] + d[0] * 0.012, q[1] + d[1] * 0.012, q[2] + d[2] * 0.012], 0.029);
         });
         yLight = t - 0.3;
-        range = 6.5;
+        range2 = 6.5;
       } else if (type === "pendant") {
         const drop = Math.max(0.4, Math.min(1.1, t - 2.05)), yc = t - drop, cs = [2763308, 15262420, 12094036, 3495534][r() * 4 | 0];
         K2.c("plain", 0, t - 0.025, 0, 0.05, 0.025, white);
         K2.c("metal", 0, yc, 0, 6e-3, drop - 0.02, 1710618);
         K2.e("plain", 0, yc - 0.09, 0, 0.19, 0.2, cs);
         K2.e("plain", 0, yc - 0.2, 0, 0.065, 0.085, 15987178);
-        emitter(() => K2.e("emissive", 0, yc - 0.2, 0, 0.069, 0.089, color));
+        emitter(() => K2.e("emissive", 0, yc - 0.2, 0, 0.069, 0.089, color2));
         yLight = yc - 0.3;
-        range = 6.5;
+        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;
         K2.c("metal", 0, yc, 0, 0.012, 0.5, gold);
@@ -3131,57 +3410,57 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         emitter(() => {
           for (let i = 0; i < N; i++) {
             const an = i * Math.PI * 2 / N;
-            K2.e("emissive", Math.cos(an) * 0.28, yc + 0.07, Math.sin(an) * 0.28, 0.0155, 0.036, color);
+            K2.e("emissive", Math.cos(an) * 0.28, yc + 0.07, Math.sin(an) * 0.28, 0.0155, 0.036, color2);
           }
         });
         yLight = yc - 0.05;
-        range = 7;
+        range2 = 7;
       } else if (type === "trough") {
         K2.b("metal", 0, t - 0.045, 0, 1.2, 0.045, 0.1, 14474456);
         K2.b("plain", 0, t - 0.058, 0, 1.12, 0.013, 0.06, 15329764);
-        emitter(() => K2.b("emissive", 0, t - 0.0605, 0, 1.125, 0.0155, 0.0625, color));
+        emitter(() => K2.b("emissive", 0, t - 0.0605, 0, 1.125, 0.0155, 0.0625, color2));
         yLight = t - 0.2;
-        range = 7;
+        range2 = 7;
       }
-      if (M.on && A.light) A.light(Object.assign({}, M, { lampId: id }), 0, yLight, 0, color, range, "ceiling_light");
+      if (M.on && A.light) A.light(Object.assign({}, M, { lampId: id }), 0, yLight, 0, color2, range2, "ceiling_light");
     }
     function tableLamp(M, A, y) {
-      const K2 = kit2(M, A, 0), color = colorTemperature(M), id = "lamp_ab_" + M.seed, cp = [15786688, 15262420, 13621470][hashString(seedKey(M.seed) + "cp") % 3], meta = { id, room: M.room, on: !!M.on, color, lightType: "table_lamp", hidden: !M.on };
+      const K2 = kit2(M, A, 0), color2 = colorTemperature(M), id = "lamp_ab_" + M.seed, cp = [15786688, 15262420, 13621470][hashString(seedKey(M.seed) + "cp") % 3], meta = { id, room: M.room, on: !!M.on, color: color2, lightType: "table_lamp", hidden: !M.on };
       K2.e("plain", 0, y + 0.045, 0, 0.065, 0.09, 3813928);
       K2.c("metal", 0, y + 0.08, 0, 8e-3, 0.14, 9075290);
       K2.c("plain", 0, y + 0.2, 0, 0.115, 0.15, cp);
-      K2.part("lamp", 0, y + 0.2, 0, () => K2.c("emissive", 0, y + 0.2, 0, 0.118, 0.152, color), meta);
-      if (M.on && A.light) A.light(Object.assign({}, M, { lampId: id }), 0, y + 0.3, 0, color, 3.5, "table_lamp");
+      K2.part("lamp", 0, y + 0.2, 0, () => K2.c("emissive", 0, y + 0.2, 0, 0.118, 0.152, color2), meta);
+      if (M.on && A.light) A.light(Object.assign({}, M, { lampId: id }), 0, y + 0.3, 0, color2, 3.5, "table_lamp");
     }
     function floorLamp(M, A) {
-      const K2 = kit2(M, A, M.y || 0), color = colorTemperature(M), id = "lamp_pe_" + M.seed, h = Math.min(1.6, M.h || 1.5), meta = { id, room: M.room, on: !!M.on, color, lightType: "floor", hidden: !M.on };
+      const K2 = kit2(M, A, M.y || 0), color2 = colorTemperature(M), id = "lamp_pe_" + M.seed, h = Math.min(1.6, M.h || 1.5), meta = { id, room: M.room, on: !!M.on, color: color2, lightType: "floor", hidden: !M.on };
       K2.c("metal", 0, 0, 0, 0.13, 0.025, 2763308);
       K2.c("metal", 0, 0.025, 0, 0.011, h - 0.3, 2763308);
       K2.c("plain", 0, h - 0.28, 0, 0.17, 0.26, 15656656);
-      K2.part("lamp", 0, h - 0.28, 0, () => K2.c("emissive", 0, h - 0.28, 0, 0.173, 0.262, color), meta);
-      if (M.on && A.light) A.light(Object.assign({}, M, { lampId: id }), 0, h - 0.15, 0, color, 5, "floor");
+      K2.part("lamp", 0, h - 0.28, 0, () => K2.c("emissive", 0, h - 0.28, 0, 0.173, 0.262, color2), meta);
+      if (M.on && A.light) A.light(Object.assign({}, M, { lampId: id }), 0, h - 0.15, 0, color2, 5, "floor");
     }
     function sconce(M, A) {
-      const K2 = kit2(M, A, M.y || 1.7), color = colorTemperature(M), id = "lamp_ar_" + M.seed, meta = { id, room: M.room, on: !!M.on, color, lightType: "sconce", hidden: !M.on };
+      const K2 = kit2(M, A, M.y || 1.7), color2 = colorTemperature(M), id = "lamp_ar_" + M.seed, meta = { id, room: M.room, on: !!M.on, color: color2, lightType: "sconce", hidden: !M.on };
       K2.b("metal", 0, -0.07, 8e-3, 0.07, 0.14, 0.016, 14210248);
       K2.t("metal", [0, 0, 0.016], [0, 0, 0.075], 0.011, 11577480);
       K2.e("plain", 0, 0, 0.1, 0.06, 0.15, 15920348);
-      K2.part("lamp", 0, 0, 0.1, () => K2.e("emissive", 0, 0, 0.1, 0.0625, 0.153, color), meta);
-      if (M.on && A.light) A.light(Object.assign({}, M, { lampId: id }), 0, 0.02, 0.2, color, 3, "sconce");
+      K2.part("lamp", 0, 0, 0.1, () => K2.e("emissive", 0, 0, 0.1, 0.0625, 0.153, color2), meta);
+      if (M.on && A.light) A.light(Object.assign({}, M, { lampId: id }), 0, 0.02, 0.2, color2, 3, "sconce");
     }
     function outdoorLamp(M, A) {
-      const K2 = kit2(M, A, M.y || 2.2), color = colorTemperature(M), id = "lamp_ext_" + M.seed, structure = STYLE(), meta = { id, room: "outside", on: !!M.on, color, lightType: "outdoor", hidden: !M.on };
+      const K2 = kit2(M, A, M.y || 2.2), color2 = colorTemperature(M), id = "lamp_ext_" + M.seed, structure = STYLE(), meta = { id, room: "outside", on: !!M.on, color: color2, lightType: "outdoor", hidden: !M.on };
       if (structure === "budget") {
         K2.c("plain", 0, -0, 0.01, 0.05, 0.02, 15921386);
         K2.t("metal", [0, 0, 0], [0, 0, 0.07], 0.022, 6974054);
         K2.e("plain", 0, 0, 0.115, 0.036, 0.085, 15987178);
-        K2.part("lamp", 0, 0, 0.115, () => K2.e("emissive", 0, 0, 0.115, 0.0385, 0.088, color), meta);
+        K2.part("lamp", 0, 0, 0.115, () => K2.e("emissive", 0, 0, 0.115, 0.0385, 0.088, color2), meta);
       } else {
         K2.b("metal", 0, -0.08, 0.01, 0.12, 0.16, 0.02, 2763308);
         K2.b("plain", 0, -0.09, 0.07, 0.11, 0.18, 0.1, 15263454);
-        K2.part("lamp", 0, -0.09, 0.07, () => K2.b("emissive", 0, -0.09, 0.07, 0.1125, 0.1825, 0.1025, color), meta);
+        K2.part("lamp", 0, -0.09, 0.07, () => K2.b("emissive", 0, -0.09, 0.07, 0.1125, 0.1825, 0.1025, color2), meta);
       }
-      if (M.on && A.light) A.light(Object.assign({}, M, { lampId: id }), 0, (M.y != null ? M.y : 2.2) - (structure === "budget" ? 0 : 0.09), structure === "budget" ? 0.2 : 0.2, color, 3.2, "outdoor", { lumens: 3.2, dist: 5.5, decay: 2 });
+      if (M.on && A.light) A.light(Object.assign({}, M, { lampId: id }), 0, (M.y != null ? M.y : 2.2) - (structure === "budget" ? 0 : 0.09), structure === "budget" ? 0.2 : 0.2, color2, 3.2, "outdoor", { lumens: 3.2, dist: 5.5, decay: 2 });
     }
     function lightSwitch(M, A) {
       const K2 = kit2(M, A, M.y != null && M.y > 0 ? M.y : 1.1), two = !!M.double;
@@ -3332,13 +3611,13 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       for (const s of lt.perimeter) {
         const alongU = Math.abs(s.v1 - s.v0) < EPS, L = alongU ? s.v0 : s.u0, a = Math.min(alongU ? s.u0 : s.v0, alongU ? s.u1 : s.v1), b = Math.max(alongU ? s.u0 : s.v0, alongU ? s.u1 : s.v1);
         cursor.pc = pieceRecord("lot_wall:" + s.id, s.type === "wall" ? "brick" : s.type === "fence" ? "wood_soft" : "steel", null, { tags: ["wall"] });
-        const th = s.thickness || 0.15, h = s.height, color = colorOf(s.color) != null ? colorOf(s.color) : C.wall || 12104874, len = b - a;
+        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);
         if (s.type === "wall") {
-          B("plaster", a, 0, b, h, th, color);
-          B("plaster", a, h, b, h + 0.05, th + 0.06, sh(color, 1.15));
+          B("plaster", a, 0, b, h, th, color2);
+          B("plaster", a, h, b, h + 0.05, th + 0.06, sh(color2, 1.15));
         } else if (s.type === "fence") {
           const np = Math.max(2, Math.round(len / 2.4) + 1);
           for (let k = 0; k < np; k++) {
@@ -3350,8 +3629,8 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
           B("metal", a, 0.08, b, 0.12, 0.03, 9080466);
         } else {
           const gc = C.gate != null ? C.gate : 2763310, mh = 0.5;
-          B("plaster", a, 0, b, mh, th, color);
-          B("plaster", a, mh, b, mh + 0.04, th + 0.05, sh(color, 1.15));
+          B("plaster", a, 0, b, mh, th, color2);
+          B("plaster", a, mh, b, mh + 0.04, th + 0.05, sh(color2, 1.15));
           const n = Math.max(2, Math.round(len / 0.13));
           for (let k = 0; k <= n; k++) {
             const u = a + k * len / n;
@@ -3400,9 +3679,9 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       cursor.group = "lot";
       for (const c of lt.paths) {
         if (c.type === "vehicle" && c.id !== "cargo_path") continue;
-        const color = c.type === "pedestrian" ? 13617856 : 11841704;
+        const color2 = c.type === "pedestrian" ? 13617856 : 11841704;
         for (const [u0, v0, u1, v1] of c.rects) {
-          bx("sidewalk", u0, 0, v0, u1, 0.05, v1, color);
+          bx("sidewalk", u0, 0, v0, u1, 0.05, v1, color2);
         }
       }
     }
@@ -3758,7 +4037,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     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";
-    function tileRelief(mat, pts, color, type) {
+    function tileRelief(mat, pts, color2, type) {
       const n = pts.length;
       if (n < 3) return;
       const [a, b, c] = pts;
@@ -3822,7 +4101,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         }
         col.push(lo <= hi ? [lo, hi] : null);
       }
-      const AC = accFor(mat), m = L.length, [cr, cg, cb] = rgbOf(color), O = cursor.org;
+      const AC = accFor(mat), m = L.length, [cr, cg, cb] = rgbOf(color2), O = cursor.org;
       AC.ensure(m * 2, (m - 1) * 6);
       const base = AC.nv, w2 = 2 * Math.PI / P;
       for (let j = 0; j < m; j++) {
@@ -4200,15 +4479,15 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
           }
         });
         const parts = [];
-        for (const { m, list, vc } of byMaterial.values()) {
+        for (const { m, list: list2, vc } of byMaterial.values()) {
           let nv = 0, ni = 0;
-          for (const e of list) {
+          for (const e of list2) {
             nv += e.P.length / 3;
             ni += e.I ? e.I.length : e.P.length / 3;
           }
           const P = new Float32Array(nv * 3), N = new Float32Array(nv * 3), U = new Float32Array(nv * 2), I = new Uint32Array(ni);
           let ov = 0, oi = 0;
-          for (const e of list) {
+          for (const e of list2) {
             const n = e.P.length / 3;
             P.set(e.P, ov * 3);
             N.set(e.N, ov * 3);
@@ -4225,7 +4504,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
           if (vc) {
             const C = new Float32Array(nv * 3);
             let q = 0;
-            for (const e of list) {
+            for (const e of list2) {
               const n = e.P.length / 3, cr = e.color;
               for (let i = 0; i < n; i++, q++) {
                 C[q * 3] = cr.r;
@@ -4336,7 +4615,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         const x = u.ry ? [u.u - uw, u.u] : [u.u, u.u + uw], z = u.ry ? [u.v - ud, u.v] : [u.v, u.v + ud];
         return [x[0], z[0], x[1], z[1]];
       };
-      const un0 = unitBox(un[0]), color = P.corridor, hall = P.hall, el = P.elevator.rect, es = P.stairs.rect;
+      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 shell = (rc, y0, y1, thickness = 0.15) => {
         const [a, b, c, d] = rc;
@@ -4356,10 +4635,10 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
             bx("glass", rc[0] + 0.5, y0 + 0.9, u.ry ? rc[1] - 1e-3 : rc[3] + 1e-3, rc[2] - 0.5, y0 + 2, u.ry ? rc[1] + 1e-3 : rc[3] + 2e-3, 16777215);
           }
         }
-        for (const rc of [color, hall]) {
+        for (const rc of [color2, hall]) {
           bx("plaster", rc[0], y0 - 0.2, rc[1], rc[2], y0, rc[3], 12104874);
         }
-        shell([Math.min(color[0], hall[0]), hall[1], color[2], color[3]], y0, y0 + pe - 0.2);
+        shell([Math.min(color2[0], hall[0]), hall[1], color2[2], color2[3]], y0, y0 + pe - 0.2);
         bx("metal", el[0] + 0.05, y0, el[1] + 0.05, el[2] - 0.05, y0 + pe, el[3] - 0.05, 8291466);
         bx("building", es[0], y0, es[1], es[2], y0 + pe - 0.2, es[3], 13618114);
         const ns = 16, rise = pe / ns, wl = es[2] - es[0] - 0.2;
@@ -4375,8 +4654,8 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         }
       }
       const ytop = N * pe - 0.2;
-      bx("plaster", Math.min(hall[0] - 3, color[0]), ytop, Math.min(un[1] ? unitBox(un[1])[1] : 0, el[1]), Math.max(color[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, color[0]), z0: Math.min(el[1], un[1] ? unitBox(un[1])[1] : 0), x1: Math.max(color[2], un0[2]), z1: Math.max(un0[3], un[1] ? unitBox(un[1])[3] : 0) };
+      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) };
     }
     Object.assign(K, { building });
   }
@@ -4466,11 +4745,11 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       return api;
     }
     const PIPE_COLOR = 11897429;
-    function pipe(a, b, diameter, color) {
+    function pipe(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);
       if (L < 1e-3) return;
       _q.setFromUnitVectors(_Y, _v3.set(dx / L, dy / L, dz / L));
-      put("plain", "cyl", (a[0] + b[0]) / 2, (a[1] + b[1]) / 2, (a[2] + b[2]) / 2, _q, diameter, L, diameter, color);
+      put("plain", "cyl", (a[0] + b[0]) / 2, (a[1] + b[1]) / 2, (a[2] + b[2]) / 2, _q, diameter, L, diameter, color2);
     }
     const _v3 = new THREE.Vector3();
     function waterPipes() {
@@ -4515,7 +4794,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       shared.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 en2 = E.serviceEntrance, KV = shared.ctx.iv ? shared.ctx.iv.plane : null;
+      const en3 = E.serviceEntrance, KV = shared.ctx.iv ? shared.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;
@@ -4531,25 +4810,25 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         for (const dx of [-0.65, -0.2, 0.25, 0.7]) cylBase("plain", u + dx, h - 0.62, v, 0.025, 0.1, 13684680);
         cursor.pc = null;
       };
-      if (en2 && en2.pole) {
-        const P = en2.pole;
+      if (en3 && en3.pole) {
+        const P = en3.pole;
         if (!(KV && KV.serviceEntrance)) pole(P.u, P.v, P.h);
         info.pole = { pos: [P.u, 0, P.v], h: P.h };
         for (const k of [-1, 1]) pole(P.u + k * 22, P.v, P.h);
         cursor.pc = pieceRecord("wiring:grid", "copper", null, { tags: ["wiring"] });
         for (const dx of [-0.65, -0.2, 0.25, 0.7]) for (const k of [-1, 1]) wireL([P.u + dx, P.h - 0.5, P.v], [P.u + k * 22 + dx, P.h - 0.5, P.v], 7e-3);
-        if (en2.drop && en2.drop.length > 1 && !(KV && KV.serviceEntrance)) {
-          const r0 = en2.drop[0], r1 = en2.drop[en2.drop.length - 1];
+        if (en3.drop && en3.drop.length > 1 && !(KV && KV.serviceEntrance)) {
+          const r0 = en3.drop[0], r1 = en3.drop[en3.drop.length - 1];
           for (const dz of [0, 0.04]) wireL([r0[0], r0[2], r0[1]], [r1[0], r1[2], r1[1] + dz], 9e-3);
           wireL([P.u - 0.2, P.h - 0.5, P.v], [r0[0], r0[2], r0[1]], 8e-3);
         }
         cursor.pc = null;
-        if (en2.descent && en2.descent.length > 1 && !(KV && KV.serviceEntrance)) {
-          const d0 = en2.descent[0], d1 = en2.descent[en2.descent.length - 1];
+        if (en3.descent && en3.descent.length > 1 && !(KV && KV.serviceEntrance)) {
+          const d0 = en3.descent[0], d1 = en3.descent[en3.descent.length - 1];
           cylBase("metal", d0[0], d1[2], d0[1], 0.02, d0[2] - d1[2], 9080466);
           bx("metal", d0[0] - 0.05, d0[2] - 0.03, d0[1] - 0.05, d0[0] + 0.05, d0[2] + 0.08, d0[1] + 0.05, 8027780);
         }
-        const M = en2.meter;
+        const M = en3.meter;
         if (M) {
           const hw = (M.w || 0.35) / 2, hd = (M.d || 0.2) / 2, hh = (M.h || 0.5) / 2, fr = M.side === "front" ? -1 : 1;
           if (!(KV && KV.meter)) bx("plain", M.u - hw, M.y - hh, M.v - hd, M.u + hw, M.y + hh, M.v + hd, 14277597);
@@ -4567,9 +4846,9 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         const g0 = cursor.group, noDrawing = !!(KV && KV.picture);
         cursor.group = "f" + Math.max(0, Math.min(nA - 1, Q.floor || 0));
         const frontU = Q.frontU || 0, frontV = Q.frontV || 0, w = Q.w || 0.3, h = Q.h || 0.4, hw = w / 2, d = 0.05;
-        const bq = (a0, y0_, a1, y1_, o0, o1, mat, color) => {
-          if (frontV) bx(mat, Q.u + a0, Q.y + y0_, Q.v + (frontV > 0 ? o0 : -o1), Q.u + a1, Q.y + y1_, Q.v + (frontV > 0 ? o1 : -o0), color);
-          else bx(mat, Q.u + (frontU > 0 ? o0 : -o1), Q.y + y0_, Q.v + a0, Q.u + (frontU > 0 ? o1 : -o0), Q.y + y1_, Q.v + a1, color);
+        const bq = (a0, y0_, a1, y1_, o0, o1, mat, color2) => {
+          if (frontV) bx(mat, Q.u + a0, Q.y + y0_, Q.v + (frontV > 0 ? o0 : -o1), Q.u + a1, Q.y + y1_, Q.v + (frontV > 0 ? o1 : -o0), color2);
+          else bx(mat, Q.u + (frontU > 0 ? o0 : -o1), Q.y + y0_, Q.v + a0, Q.u + (frontU > 0 ? o1 : -o0), Q.y + y1_, Q.v + a1, color2);
         };
         if (!noDrawing) {
           bq(-hw, -h / 2, hw, h / 2, -0.015, 0.06, "plain", 13619926);
@@ -4613,11 +4892,11 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       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;
     }
-    function pipe2(a, b, diameter, color) {
+    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);
       if (L < 1e-3) return;
       _q.setFromUnitVectors(_Y, _v3.set(dx / L, dy / L, dz / L));
-      put("plain", "cyl", (a[0] + b[0]) / 2, (a[1] + b[1]) / 2, (a[2] + b[2]) / 2, _q, diameter, L, diameter, color);
+      put("plain", "cyl", (a[0] + b[0]) / 2, (a[1] + b[1]) / 2, (a[2] + b[2]) / 2, _q, diameter, L, diameter, color2);
     }
     Object.assign(K, { electricalStructure, pipe2 });
   }
@@ -4627,7 +4906,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     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, color = sh(shared.ctx.colors.facade != null ? shared.ctx.colors.facade : 14209216, 0.62), y0 = Y0(0), cal = 13947078;
+      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 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 };
@@ -4653,7 +4932,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
           if (A.au) bx(mat, s0, y1, lo, s1, y2, hi, c);
           else bx(mat, lo, y1, s0, hi, y2, s1, c);
         };
-        strip(t, y0, y0 + ht, 0, t, "plaster", color);
+        strip(t, y0, y0 + ht, 0, t, "plaster", color2);
         strip(W, y0, y0 + 0.045, 0, W, "sidewalk", cal);
       }
     }
@@ -4702,7 +4981,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
           tilt = Math.atan2(yA - yB, d);
           yc = yC + 0.13;
         }
-        const co = Math.cos(tilt), si = Math.sin(tilt), pb = (lx, ly, lz, sx, sy, sz, mat, color) => boxC(mat, p.u + lx, yc + ly * co - lz * si, p.v + ly * si + lz * co, sx, sy, sz, color, tilt, 0, 0), L = p.length;
+        const co = Math.cos(tilt), si = Math.sin(tilt), pb = (lx, ly, lz, sx, sy, sz, mat, color2) => boxC(mat, p.u + lx, yc + ly * co - lz * si, p.v + ly * si + lz * co, sx, sy, sz, color2, tilt, 0, 0), L = p.length;
         pb(0, 0, 0, p.w, 0.04, L, "metal", silver);
         pb(0, 0.0205, 0, p.w - 0.07, 6e-3, L - 0.07, "plain", blue);
         for (let k = 1; k < 4; k++) pb(-hw + 0.035 + k * (p.w - 0.07) / 4, 0.0245, 0, 6e-3, 3e-3, L - 0.07, "metal", line);
@@ -4794,39 +5073,39 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         return [M.x + lx * c + lz * s, M.z - lx * s + lz * c];
       };
       return {
-        box(M, mat, x, y, z, w, h, d, color, ry = 0, rx = 0, rz = 0) {
+        box(M, mat, x, y, z, w, h, d, color2, ry = 0, rx = 0, rz = 0) {
           const [px, pz] = loc(M, x, z);
-          boxC(mm(mat), px, M.base + y + h / 2, pz, w, h, d, color, rx, M.ry + ry, rz);
+          boxC(mm(mat), px, M.base + y + h / 2, pz, w, h, d, color2, rx, M.ry + ry, rz);
         },
-        cylinder(M, mat, x, y, z, r, h, color, rx = 0, rz = 0, seg) {
+        cylinder(M, mat, x, y, z, r, h, color2, rx = 0, rz = 0, seg) {
           const [px, pz] = loc(M, x, z);
           _q.setFromEuler(_e.set(rx || 0, M.ry, rz || 0, "YXZ"));
-          put(mm(mat), seg || "cyl", px, M.base + y + (rx || rz ? 0 : h / 2), pz, _q, r * 2, h, r * 2, color);
+          put(mm(mat), seg || "cyl", px, M.base + y + (rx || rz ? 0 : h / 2), pz, _q, r * 2, h, r * 2, color2);
         },
-        leaf(M, x, y, z, w, h, color, ry = 0, rx = 0) {
+        leaf(M, x, y, z, w, h, color2, ry = 0, rx = 0) {
           const [px, pz] = loc(M, x, z), a = M.ry + (ry || 0), ca = Math.cos(a), sa = Math.sin(a), t1 = (rx || 0) * 0.8, t2 = (rx || 0) * 1.5, y0 = M.base + y;
           const P = (lx, ly, lz) => [px + lx * ca + lz * sa, y0 + ly, pz - lx * sa + lz * ca];
           const my = Math.cos(t1) * h * 0.5, mz = Math.sin(t1) * h * 0.5, ty = my + Math.cos(t2) * h * 0.5, tz = mz + Math.sin(t2) * h * 0.5, f = w * 0.5, dn = f * 0.32;
           const B = P(0, 0, 0), Mi = P(0, my + 4e-3, mz), T2 = P(0, ty, tz), L = P(-f, my - dn, mz - dn * 0.3), R = P(f, my - dn, mz - dn * 0.3);
-          polyFace("plant", [B, L, T2, Mi], color, [0, 1, 0]);
-          polyFace("plant", [B, Mi, T2, R], sh(color, 0.92), [0, 1, 0]);
+          polyFace("plant", [B, L, T2, Mi], color2, [0, 1, 0]);
+          polyFace("plant", [B, Mi, T2, R], sh(color2, 0.92), [0, 1, 0]);
         },
-        plane(M, mat, x, y, z, w, h, color, ry = 0, rx = 0, rz = 0, uv) {
+        plane(M, mat, x, y, z, w, h, color2, ry = 0, rx = 0, rz = 0, uv) {
           const [px, pz] = loc(M, x, z);
           _q.setFromEuler(_e.set(rx || 0, M.ry + (ry || 0), rz || 0, "YXZ"));
           if (uv && mat === "atlas_floor") {
             const col = Math.floor(uv.u0 * 4 + 1e-6), lin = uv.v0 < 0.5 ? 1 : 0, cell = col + 4 * lin, h0 = _h2(Math.round(px * 8), Math.round(pz * 8)), type = cell === 5 ? "dirt" : cell === 0 || cell === 1 ? "lawn" : null;
             if (type === "dirt") {
-              put("dirt", "plane", px, M.base + y, pz, _q, w, h, 1, sh(color, 1 / 0.965));
+              put("dirt", "plane", px, M.base + y, pz, _q, w, h, 1, sh(color2, 1 / 0.965));
               return;
             }
             if (type) uv = { u0: uv.u0, u1: uv.u1, v0: uv.v0, v1: uv.v1, rot: h0 * 4 | 0, fx: h0 > 0.5 ? 1 : 0, vc: (wx, wz) => macroGround(wx, wz, type) };
           }
-          put(mm(mat), "plane", px, M.base + y, pz, _q, w, h, 1, color, uv);
+          put(mm(mat), "plane", px, M.base + y, pz, _q, w, h, 1, color2, uv);
         },
-        light(M, x, y, z, color, range, type, ex) {
+        light(M, x, y, z, color2, range2, type, ex) {
           const [px, pz] = loc(M, x, z);
-          LIGHTS.push(Object.assign({ x: px, y: M.base + y, z: pz, color, range, type, floor: M.floor, group: cursor.group, base: M.base, room: M.room, id: M.lampId }, ex || null));
+          LIGHTS.push(Object.assign({ x: px, y: M.base + y, z: pz, color: color2, range: range2, type, floor: M.floor, group: cursor.group, base: M.base, room: M.room, id: M.lampId }, ex || null));
         }
       };
     }
@@ -4841,7 +5120,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     }
     function kk(M, A) {
       const y0 = M.y || 0;
-      return { b: (mat, x, y, z, w, h, d, color, ry, rx, rz) => A.box(M, mat, x, y0 + y, z, w, h, d, color, ry || 0, rx || 0, rz || 0), c: (mat, x, y, z, r, h, color, rx, rz, seg) => A.cylinder(M, mat, x, y0 + y, z, r, h, color, rx || 0, rz || 0, seg), rnd: rngOf(M), wood: paletteColor(M, "wood", 8016948), met: paletteColor(M, "metal", 10133154) };
+      return { b: (mat, x, y, z, w, h, d, color2, ry, rx, rz) => A.box(M, mat, x, y0 + y, z, w, h, d, color2, ry || 0, rx || 0, rz || 0), c: (mat, x, y, z, r, h, color2, rx, rz, seg) => A.cylinder(M, mat, x, y0 + y, z, r, h, color2, rx || 0, rz || 0, seg), rnd: rngOf(M), wood: paletteColor(M, "wood", 8016948), met: paletteColor(M, "metal", 10133154) };
     }
     const PE = Math.PI / 2;
     Object.assign(K, { MATERIAL_MAP: MATERIAL_MAP2, mm, LIGHTS, makeApi, sh, paletteColor, rngOf, kk, PE });
@@ -5016,13 +5295,13 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         lb("metal", 0, h - 0.23, d / 2 + 0.04, w - 0.12, 0.02, 0.02, 10526880);
       },
       kitchen_cabinet(M, A, o = {}) {
-        const { b: lb, c: lc } = kk(M, A), w = M.w, d = M.d, h = M.h || 0.95, color = paletteColor(M, "wall_kitchen", 15262420), wood = paletteColor(M, "wood", 11571296);
-        lb("plain", 0, 0.08, -0.02, w, h - 0.15, d - 0.05, color);
+        const { b: lb, c: lc } = kk(M, A), w = M.w, d = M.d, h = M.h || 0.95, color2 = paletteColor(M, "wall_kitchen", 15262420), wood = paletteColor(M, "wood", 11571296);
+        lb("plain", 0, 0.08, -0.02, w, h - 0.15, d - 0.05, color2);
         lb("plain", 0, 0, 0, w - 0.04, 0.08, d - 0.12, 2763306);
         const nd = Math.max(2, Math.round(w / 0.55));
         for (let k = 0; k < nd; k++) {
           const u = -w / 2 + (k + 0.5) * w / nd;
-          lb("plain", u, 0.12, d / 2 - 0.02, w / nd - 0.03, h - 0.28, 0.02, sh(color, 1.06));
+          lb("plain", u, 0.12, d / 2 - 0.02, w / nd - 0.03, h - 0.28, 0.02, sh(color2, 1.06));
           lb("metal", u + (k % 2 ? -0.2 : 0.2) * (w / nd), h * 0.62, d / 2, 0.012, 0.12, 0.015, 9079434);
         }
         if (o.noBasin) lb("plain", 0, h - 0.07, 0, w + 0.03, 0.035, d + 0.03, 4868164);
@@ -5044,13 +5323,13 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         }
         if (!o.noOverhead && (M.overhead === true || M.overhead == null && w >= 1.2)) {
           const ya = 1.55;
-          lb("plain", 0, ya, -d / 2 + 0.18, w, 0.6, 0.35, color);
-          for (let k = 0; k < 3; k++) lb("plain", -w / 2 + (k + 0.5) * w / 3, ya + 0.02, -d / 2 + 0.36, w / 3 - 0.03, 0.56, 0.015, sh(color, 1.06));
+          lb("plain", 0, ya, -d / 2 + 0.18, w, 0.6, 0.35, color2);
+          for (let k = 0; k < 3; k++) lb("plain", -w / 2 + (k + 0.5) * w / 3, ya + 0.02, -d / 2 + 0.36, w / 3 - 0.03, 0.56, 0.015, sh(color2, 1.06));
         }
       },
       counter(M, A, o = {}) {
-        const { b: lb } = kk(M, A), w = M.w, d = M.d, h = M.h, color = o.color != null ? o.color : paletteColor(M, "wood", 9071176), top = o.top != null ? o.top : 14210252;
-        lb("plain", 0, 0, 0, w, h * (o.glass ? 0.45 : 1) - 0.04, d, color);
+        const { b: lb } = kk(M, A), w = M.w, d = M.d, h = M.h, color2 = o.color != null ? o.color : paletteColor(M, "wood", 9071176), top = o.top != null ? o.top : 14210252;
+        lb("plain", 0, 0, 0, w, h * (o.glass ? 0.45 : 1) - 0.04, d, color2);
         lb("plain", 0, h * (o.glass ? 0.45 : 1) - 0.04, 0, w + 0.03, 0.04, d + 0.03, top);
         if (o.glass) {
           lb("glass", 0, h * 0.45, 0, w - 0.04, h * 0.55, d - 0.04, 16777215);
@@ -5320,9 +5599,9 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         lb("glass", w * 0.28, 1, d / 2 + 0.01, 0.8, 0.9, 0.02, 16777215);
       },
       motorcycle(M, A) {
-        const { b: lb, c: lc } = kk(M, A), d = M.d, color = M.color != null ? M.color : 11024948;
+        const { b: lb, c: lc } = kk(M, A), d = M.d, color2 = M.color != null ? M.color : 11024948;
         for (const s of [-1, 1]) lc("plain", 0, 0.3, s * d * 0.34, 0.3, 0.12, 1710618, 0, PE);
-        lb("plain", 0, 0.35, 0, 0.18, 0.28, d * 0.5, color);
+        lb("plain", 0, 0.35, 0, 0.18, 0.28, d * 0.5, color2);
         lb("plain", 0, 0.62, -0.1, 0.22, 0.1, 0.6, 2236962);
         lb("metal", 0, 0.7, d * 0.28, 0.5, 0.04, 0.04, 11580600);
       },
@@ -5667,13 +5946,13 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     };
     FURNITURE.curtain = function(M, A) {
       const w = M.w || 1.6, h = M.h || 2.3, y = M.y != null && M.y > 0 ? M.y : 0.1, K2 = kit2(M, A, 0), top = y + h;
-      const rnd = rngString(SEED() + "|" + seedKey(M.seed) + "|cort"), color = M.color != null ? M.color : [14208436, 10465470, 12953740, 14736592][rnd() * 4 | 0], gold = M.palette && M.palette.metal != null ? M.palette.metal : 5918792;
+      const rnd = rngString(SEED() + "|" + seedKey(M.seed) + "|cort"), color2 = M.color != null ? M.color : [14208436, 10465470, 12953740, 14736592][rnd() * 4 | 0], gold = M.palette && M.palette.metal != null ? M.palette.metal : 5918792;
       K2.t("metal", [-w / 2 - 0.05, top + 0.02, 0], [w / 2 + 0.05, top + 0.02, 0], 0.012, gold);
       for (const s of [-1, 1]) K2.e("metal", s * (w / 2 + 0.07), top + 0.02, 0, 0.022, 0.045, gold);
       const pw = w / 2 + 0.03, n = Math.max(8, Math.round(pw / 0.075));
       for (const s of [-1, 1]) for (let i = 0; i < n; i++) {
         const ux = s * (i + 0.5) * pw / n;
-        K2.b("fabric", ux, y, i % 2 ? 0.03 : -0.012, pw / n * 1.12, h - 0.04, 0.018, i % 2 ? sh(color, 0.88) : color);
+        K2.b("fabric", ux, y, i % 2 ? 0.03 : -0.012, pw / n * 1.12, h - 0.04, 0.018, i % 2 ? sh(color2, 0.88) : color2);
       }
       for (const s of [-1, 1]) for (let i = 0; i < n; i += 2) K2.e("metal", s * (i + 0.5) * pw / n, top + 0.012, 0, 0.012, 0.024, gold);
     };
@@ -5696,15 +5975,15 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         }
       }
     }
-    function potModel(K2, x, y, z, r, h, color, soil = true) {
+    function potModel(K2, x, y, z, r, h, color2, soil = true) {
       const rimR = r * 1.1;
-      K2.c("plain", x, y, z, r * 0.62, h * 0.55, sh(color, 0.92));
-      K2.c("plain", x, y + h * 0.5, z, r * 0.84, h * 0.34, color);
-      K2.c("plain", x, y + h * 0.82, z, rimR, h * 0.18, sh(color, 1.08));
+      K2.c("plain", x, y, z, r * 0.62, h * 0.55, sh(color2, 0.92));
+      K2.c("plain", x, y + h * 0.5, z, r * 0.84, h * 0.34, color2);
+      K2.c("plain", x, y + h * 0.82, z, rimR, h * 0.18, sh(color2, 1.08));
       if (soil) K2.c("plain", x, y + h * 0.995, z, r * 0.92, h * 0.012, 3811870);
       return y + h;
     }
-    function arcLeaf(K2, bx_, by, bz, az, len, elev, drop, wmax, color, serrated, nSeg = 6) {
+    function arcLeaf(K2, bx_, by, bz, az, len, elev, drop, wmax, color2, serrated, nSeg = 6) {
       const c = Math.cos(az), s = Math.sin(az), pts = [];
       for (let i = 0; i <= nSeg; i++) {
         const f = i / nSeg, d = f * len;
@@ -5713,14 +5992,14 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       const px = -s, pz = c;
       for (let i = 0; i < nSeg; i++) {
         const f0 = i / nSeg, f1 = (i + 1) / nSeg, w0 = wmax * Math.sin(Math.PI * Math.min(1, f0 * 0.85 + 0.12)) * (serrated && i % 2 ? 0.7 : 1), w1 = wmax * Math.sin(Math.PI * Math.min(1, f1 * 0.85 + 0.12)) * (serrated && i % 2 ? 1 : 0.7), dn = 0.35;
-        for (const sd of [-1, 1]) K2.polyFace("plant", [pts[i], pts[i + 1], [pts[i + 1][0] + px * sd * w1, pts[i + 1][1] - w1 * dn, pts[i + 1][2] + pz * sd * w1], [pts[i][0] + px * sd * w0, pts[i][1] - w0 * dn, pts[i][2] + pz * sd * w0]], i % 2 ? sh(color, 0.9) : color, [0, 1, 0]);
+        for (const sd of [-1, 1]) K2.polyFace("plant", [pts[i], pts[i + 1], [pts[i + 1][0] + px * sd * w1, pts[i + 1][1] - w1 * dn, pts[i + 1][2] + pz * sd * w1], [pts[i][0] + px * sd * w0, pts[i][1] - w0 * dn, pts[i][2] + pz * sd * w0]], i % 2 ? sh(color2, 0.9) : color2, [0, 1, 0]);
       }
       return pts[nSeg];
     }
-    function tuft(K2, x, y, z, r, n, color, rnd) {
+    function tuft(K2, x, y, z, r, n, color2, rnd) {
       for (let i = 0; i < n; i++) {
         const a = rnd() * 6.283, d0 = rnd() * r * 0.35, L = r * (0.8 + rnd() * 1.1), bw = 0.012 + rnd() * 8e-3, lean = 0.25 + rnd() * 0.5, c = Math.cos(a), s = Math.sin(a), px = -s, pz = c, x0 = x + c * d0, z0 = z + s * d0;
-        const m = [x0 + c * lean * L * 0.35, y + L * 0.55, z0 + s * lean * L * 0.35], t = [x0 + c * lean * L, y + L * (0.95 - lean * 0.2), z0 + s * lean * L], vc = sh(color, 0.78 + rnd() * 0.4);
+        const m = [x0 + c * lean * L * 0.35, y + L * 0.55, z0 + s * lean * L * 0.35], t = [x0 + c * lean * L, y + L * (0.95 - lean * 0.2), z0 + s * lean * L], vc = sh(color2, 0.78 + rnd() * 0.4);
         K2.polyFace("plant", [[x0 - px * bw, y, z0 - pz * bw], [x0 + px * bw, y, z0 + pz * bw], [m[0] + px * bw * 0.6, m[1], m[2] + pz * bw * 0.6], t, [m[0] - px * bw * 0.6, m[1], m[2] - pz * bw * 0.6]], vc, [0, 1, 0]);
       }
     }
@@ -5811,31 +6090,31 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     const seedKey = (id) => K.seedKey(id);
     const { FURNITURE, SEED, STYLE, kit2, rngString, sh, wallTap } = K;
     FURNITURE.laundry_tub = function(M, A) {
-      const K2 = kit2(M, A), w = M.w || 0.6, d = M.d || 0.55, H = M.h || 0.9, structure = STYLE(), upper = structure === "budget", color = upper ? 11841700 : 15790058, int = upper ? 10134694 : 14870248, rim = sh(color, 1.06);
+      const K2 = kit2(M, A), w = M.w || 0.6, d = M.d || 0.55, H = M.h || 0.9, structure = STYLE(), upper = structure === "budget", color2 = upper ? 11841700 : 15790058, int2 = upper ? 10134694 : 14870248, rim = sh(color2, 1.06);
       const yb = H - 0.36, t = 0.04, rc = 0.055, zw = -d / 2;
-      for (const sx of [-1, 1]) for (const sz of [-1, 1]) K2.c("plain", sx * (w / 2 - rc), yb, sz * (d / 2 - rc), rc, 0.36, color);
-      K2.b("plain", 0, yb, d / 2 - t / 2, w - 2 * rc + 0.01, 0.36, t, color);
-      K2.b("plain", 0, yb, -d / 2 + t / 2, w - 2 * rc + 0.01, 0.36, t, color);
-      K2.b("plain", -w / 2 + t / 2, yb, 0, t, 0.36, d - 2 * rc + 0.01, color);
-      K2.b("plain", w / 2 - t / 2, yb, 0, t, 0.36, d - 2 * rc + 0.01, color);
-      K2.b("plain", 0, yb, 0, w - 2 * t, 0.06, d - 2 * t, int);
+      for (const sx of [-1, 1]) for (const sz of [-1, 1]) K2.c("plain", sx * (w / 2 - rc), yb, sz * (d / 2 - rc), rc, 0.36, color2);
+      K2.b("plain", 0, yb, d / 2 - t / 2, w - 2 * rc + 0.01, 0.36, t, color2);
+      K2.b("plain", 0, yb, -d / 2 + t / 2, w - 2 * rc + 0.01, 0.36, t, color2);
+      K2.b("plain", -w / 2 + t / 2, yb, 0, t, 0.36, d - 2 * rc + 0.01, color2);
+      K2.b("plain", w / 2 - t / 2, yb, 0, t, 0.36, d - 2 * rc + 0.01, color2);
+      K2.b("plain", 0, yb, 0, w - 2 * t, 0.06, d - 2 * t, int2);
       for (const sx of [-1, 1]) for (const sz of [-1, 1]) K2.c("plain", sx * (w / 2 - rc), H - 4e-3, sz * (d / 2 - rc), rc + 8e-3, 0.012, rim);
       K2.b("plain", 0, H - 4e-3, d / 2 - 0.011, w - 2 * rc, 0.012, 0.022, rim);
       K2.b("plain", 0, H - 4e-3, -d / 2 + 0.011, w - 2 * rc, 0.012, 0.022, rim);
       K2.b("plain", -w / 2 + 0.011, H - 4e-3, 0, 0.022, 0.012, d - 2 * rc, rim);
       K2.b("plain", w / 2 - 0.011, H - 4e-3, 0, 0.022, 0.012, d - 2 * rc, rim);
       const tw = Math.min(0.2, w * 0.34), tx = -w / 2 + t + tw / 2 + 0.01, zt1 = d / 2 - t - 0.01, zt0 = -d / 2 + t + 0.08, ytop = H - 0.03, ybot = yb + 0.14, L = Math.hypot(zt1 - zt0, ytop - ybot), al = Math.atan2(ytop - ybot, zt1 - zt0);
-      K2.b("plain", tx, (ytop + ybot) / 2 - 0.015, (zt0 + zt1) / 2, tw, 0.03, L, sh(color, 0.96), 0, -al, 0);
+      K2.b("plain", tx, (ytop + ybot) / 2 - 0.015, (zt0 + zt1) / 2, tw, 0.03, L, sh(color2, 0.96), 0, -al, 0);
       const nr = 7;
       for (let i = 0; i < nr; i++) {
         const f = (i + 0.5) / nr, zz = zt0 + (zt1 - zt0) * f, yy = ybot + (ytop - ybot) * f;
-        K2.b("plain", tx, yy + 3e-3, zz, tw - 0.02, 0.014, 0.018, sh(color, 0.88), 0, -al, 0);
+        K2.b("plain", tx, yy + 3e-3, zz, tw - 0.02, 0.014, 0.018, sh(color2, 0.88), 0, -al, 0);
       }
       K2.c("metal", 0.1, yb + 0.06, 0, 0.034, 8e-3, 11580600);
       K2.c("plain", 0.1, yb + 0.068, 0, 0.026, 0.01, 3817026);
       if (upper) {
-        for (const sx of [-1, 1]) K2.b("plain", sx * (w / 2 - 0.035), 0, 0, 0.07, yb, d - 0.05, sh(color, 0.94));
-        K2.b("plain", 0, yb - 0.04, 0, w - 0.1, 0.04, d - 0.06, sh(color, 0.9));
+        for (const sx of [-1, 1]) K2.b("plain", sx * (w / 2 - 0.035), 0, 0, 0.07, yb, d - 0.05, sh(color2, 0.94));
+        K2.b("plain", 0, yb - 0.04, 0, w - 0.1, 0.04, d - 0.06, sh(color2, 0.9));
       } else for (const sx of [-1, 1]) for (const sz of [-1, 1]) {
         K2.c("metal", sx * (w / 2 - 0.07), 0, sz * (d / 2 - 0.07), 0.022, yb, 11843772);
         K2.c("metal", sx * (w / 2 - 0.07), 0, sz * (d / 2 - 0.07), 0.03, 0.012, 6975090);
@@ -5843,30 +6122,30 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       wallTap(K2, 0, H + 0.14, zw + 0, 1, yb + 0.06, { laundry_tub: true });
     };
     const CLOTHES_COLORS = [14209208, 4876938, 12077114, 15262936, 6982234, 14856266, 9067146, 3099242, 13925002, 8038072];
-    function strip(K2, rows, zc, rot, color, cx) {
+    function strip(K2, rows, zc, rot, color2, cx) {
       const c = Math.cos(rot), s = Math.sin(rot), P = (x, y) => [cx + (x - cx) * c, y, zc + (x - cx) * s];
       for (let i = 0; i < rows.length - 1; i++) {
         const a = rows[i], b = rows[i + 1];
-        K2.polyFace("clothes", [P(a[1], a[0]), P(a[2], a[0]), P(b[2], b[0]), P(b[1], b[0])], i % 2 ? sh(color, 0.96) : color, [0, 0, 1]);
+        K2.polyFace("clothes", [P(a[1], a[0]), P(a[2], a[0]), P(b[2], b[0]), P(b[1], b[0])], i % 2 ? sh(color2, 0.96) : color2, [0, 0, 1]);
       }
     }
-    function garment(K2, type, cx, ly, zc, rot, color, rnd) {
+    function garment(K2, type, cx, ly, zc, rot, color2, rnd) {
       const sh0 = (rows, dx = 0) => rows.map((r) => [ly + r[0], cx + dx + r[1], cx + dx + r[2]]);
-      if (type === "shirt") strip(K2, sh0([[0, -0.13, 0.13], [-0.03, -0.27, 0.27], [-0.15, -0.3, 0.3], [-0.2, -0.2, 0.2], [-0.62, -0.2, 0.2], [-0.63, -0.2, 0.2]]), zc, rot, color, cx);
+      if (type === "shirt") strip(K2, sh0([[0, -0.13, 0.13], [-0.03, -0.27, 0.27], [-0.15, -0.3, 0.3], [-0.2, -0.2, 0.2], [-0.62, -0.2, 0.2], [-0.63, -0.2, 0.2]]), zc, rot, color2, cx);
       else if (type === "trousers") {
-        strip(K2, sh0([[0, -0.19, -0.01], [-0.4, -0.18, -0.02], [-0.78, -0.16, -0.03], [-0.79, -0.16, -0.03]]), zc, rot, color, cx);
-        strip(K2, sh0([[0, 0.01, 0.19], [-0.4, 0.02, 0.18], [-0.78, 0.03, 0.16], [-0.79, 0.03, 0.16]]), zc, rot, sh(color, 0.95), cx);
+        strip(K2, sh0([[0, -0.19, -0.01], [-0.4, -0.18, -0.02], [-0.78, -0.16, -0.03], [-0.79, -0.16, -0.03]]), zc, rot, color2, cx);
+        strip(K2, sh0([[0, 0.01, 0.19], [-0.4, 0.02, 0.18], [-0.78, 0.03, 0.16], [-0.79, 0.03, 0.16]]), zc, rot, sh(color2, 0.95), cx);
       } else if (type === "shorts") {
-        strip(K2, sh0([[0, -0.2, -0.01], [-0.3, -0.2, -0.02], [-0.31, -0.2, -0.02]]), zc, rot, color, cx);
-        strip(K2, sh0([[0, 0.01, 0.2], [-0.3, 0.02, 0.2], [-0.31, 0.02, 0.2]]), zc, rot, sh(color, 0.95), cx);
+        strip(K2, sh0([[0, -0.2, -0.01], [-0.3, -0.2, -0.02], [-0.31, -0.2, -0.02]]), zc, rot, color2, cx);
+        strip(K2, sh0([[0, 0.01, 0.2], [-0.3, 0.02, 0.2], [-0.31, 0.02, 0.2]]), zc, rot, sh(color2, 0.95), cx);
       } else if (type === "towel") {
-        strip(K2, sh0([[0, -0.32, 0.32], [-0.2, -0.32, 0.32], [-0.22, -0.32, 0.32], [-0.5, -0.32, 0.32], [-0.9, -0.32, 0.32], [-0.91, -0.32, 0.32]]), zc, rot, color, cx);
-        strip(K2, sh0([[-0.22, -0.32, 0.32], [-0.3, -0.32, 0.32]]), zc, rot, sh(color, 1.25), cx);
-      } else if (type === "sheet") strip(K2, sh0([[0, -0.5, 0.5], [-0.35, -0.5, 0.5], [-0.7, -0.5, 0.5], [-1.05, -0.5, 0.5], [-1.06, -0.5, 0.5]]), zc, rot, color, cx);
-      else if (type === "dress") strip(K2, sh0([[0, -0.14, 0.14], [-0.06, -0.2, 0.2], [-0.3, -0.16, 0.16], [-0.62, -0.28, 0.28], [-0.63, -0.28, 0.28]]), zc, rot, color, cx);
+        strip(K2, sh0([[0, -0.32, 0.32], [-0.2, -0.32, 0.32], [-0.22, -0.32, 0.32], [-0.5, -0.32, 0.32], [-0.9, -0.32, 0.32], [-0.91, -0.32, 0.32]]), zc, rot, color2, cx);
+        strip(K2, sh0([[-0.22, -0.32, 0.32], [-0.3, -0.32, 0.32]]), zc, rot, sh(color2, 1.25), cx);
+      } else if (type === "sheet") strip(K2, sh0([[0, -0.5, 0.5], [-0.35, -0.5, 0.5], [-0.7, -0.5, 0.5], [-1.05, -0.5, 0.5], [-1.06, -0.5, 0.5]]), zc, rot, color2, cx);
+      else if (type === "dress") strip(K2, sh0([[0, -0.14, 0.14], [-0.06, -0.2, 0.2], [-0.3, -0.16, 0.16], [-0.62, -0.28, 0.28], [-0.63, -0.28, 0.28]]), zc, rot, color2, cx);
       else {
-        strip(K2, sh0([[0, -0.05, 0.05], [-0.14, -0.05, 0.05], [-0.15, -0.05, 0.05]], -0.06), zc, rot, color, cx);
-        strip(K2, sh0([[0, -0.05, 0.05], [-0.14, -0.05, 0.05], [-0.15, -0.05, 0.05]], 0.06), zc, rot, sh(color, 0.9), cx);
+        strip(K2, sh0([[0, -0.05, 0.05], [-0.14, -0.05, 0.05], [-0.15, -0.05, 0.05]], -0.06), zc, rot, color2, cx);
+        strip(K2, sh0([[0, -0.05, 0.05], [-0.14, -0.05, 0.05], [-0.15, -0.05, 0.05]], 0.06), zc, rot, sh(color2, 0.9), cx);
       }
       K2.b("plain", cx - 0.05, ly - 0.02, zc, 0.018, 0.05, 0.016, 15261896);
       K2.b("plain", cx + 0.05, ly - 0.02, zc, 0.018, 0.05, 0.016, 13125690);
@@ -5900,7 +6179,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       (shared.ctx.clotheslines || (shared.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, color = M.palette && M.palette.tank_water != null ? M.palette.tank_water : 3107496, r = Math.min(w, d) * 0.46, rc = 11841700;
+      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;
       let y0 = 0;
       if (onGround) {
         for (const sx of [-1, 1]) for (const sz of [-1, 1]) K2.b("plain", sx * (w / 2 - 0.08), 0, sz * (d / 2 - 0.08), 0.14, 1, 0.14, rc);
@@ -5912,10 +6191,10 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       }
       const H = Math.max(0.7, (M.h || 1.8) - (onGround ? 1.12 : 0.1) - 0), th = Math.min(0.95, H * 0.88);
       K2.part("water_tank", 0, y0, 0, () => {
-        K2.c("plain", 0, y0, 0, r, th, color);
-        for (const f of [0.18, 0.5, 0.82]) K2.c("plain", 0, y0 + th * f - 0.025, 0, r * 1.028, 0.05, sh(color, 0.88));
-        K2.e("plain", 0, y0 + th + 0.03, 0, r * 1, 0.16, sh(color, 0.95));
-        K2.c("plain", 0, y0 + th + 0.09, 0, r * 0.5, 0.05, sh(color, 0.8));
+        K2.c("plain", 0, y0, 0, r, th, color2);
+        for (const f of [0.18, 0.5, 0.82]) K2.c("plain", 0, y0 + th * f - 0.025, 0, r * 1.028, 0.05, sh(color2, 0.88));
+        K2.e("plain", 0, y0 + th + 0.03, 0, r * 1, 0.16, sh(color2, 0.95));
+        K2.c("plain", 0, y0 + th + 0.09, 0, r * 0.5, 0.05, sh(color2, 0.8));
         K2.c("plain", 0, y0 + th + 0.14, 0, r * 0.18, 0.035, 1916262);
       }, { id: "tank_" + M.seed, breakable: true, fluid: "water", volume: Math.PI * r * r * th, radius: r, height: th });
       K2.t("metal", [r * 0.7, y0 + th * 0.25, 0], [r * 0.7, y0 + 0.03, 0], 0.02, 3159096);
@@ -5924,13 +6203,13 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       K2.t("metal", [-r * 0.5, y0 + th + 0.35, 0], [-r * 0.2, y0 + th + 0.35, 0], 0.014, 2763306);
     };
     FURNITURE.cooking_gas_cylinder = function(M, A) {
-      const K2 = kit2(M, A), r = Math.min(M.w || 0.36, M.d || 0.36) / 2, H = M.h || 0.47, color = 4157096, scale = sh(color, 0.7), brass = 13214282, c = Math.cos(M.ry || 0), s = Math.sin(M.ry || 0);
+      const K2 = kit2(M, A), r = Math.min(M.w || 0.36, M.d || 0.36) / 2, H = M.h || 0.47, color2 = 4157096, scale = sh(color2, 0.7), brass = 13214282, c = Math.cos(M.ry || 0), s = Math.sin(M.ry || 0);
       K2.part("gas_cylinder", 0, 0, 0, () => {
         K2.c("plain", 0, 0, 0, r * 0.88, 0.05, scale);
-        K2.c("plain", 0, 0.04, 0, r, H * 0.5, color);
-        K2.e("plain", 0, 0.04 + H * 0.5, 0, r * 0.99, 0.08, sh(color, 0.9));
+        K2.c("plain", 0, 0.04, 0, r, H * 0.5, color2);
+        K2.e("plain", 0, 0.04 + H * 0.5, 0, r * 0.99, 0.08, sh(color2, 0.9));
         K2.c("plain", 0, H * 0.5 + 0.04, 0, r * 1.012, 0.018, scale);
-        K2.e("plain", 0, H * 0.77, 0, r * 0.98, H * 0.36, color);
+        K2.e("plain", 0, H * 0.77, 0, r * 0.98, H * 0.36, color2);
         K2.c("metal", 0, H * 0.86, 0, 0.05, 0.05, 9080466);
         for (let k = 0; k < 3; k++) {
           const a = k * 2.0944 + 0.5, x = Math.cos(a) * r * 0.62, z = Math.sin(a) * r * 0.62;
@@ -5989,8 +6268,8 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     function extraTypes(T2, props) {
       const origCar = T2.garage_car;
       const car = (M, A) => {
-        const structure = STYLE(), list = CAR_BY_STYLE[structure] || CAR_BY_STYLE.mid, r = rngString(SEED() + "|" + (seedKey(M.seed) || M.id || "") + "|" + Math.round((M.x || 0) * 10) + "|" + Math.round((M.z || 0) * 10) + "|carro");
-        const k = list[Math.floor(r() * list.length)], paint = 1 + Math.floor(r() * 8);
+        const structure = STYLE(), list2 = CAR_BY_STYLE[structure] || CAR_BY_STYLE.mid, r = rngString(SEED() + "|" + (seedKey(M.seed) || M.id || "") + "|" + Math.round((M.x || 0) * 10) + "|" + Math.round((M.z || 0) * 10) + "|carro");
+        const k = list2[Math.floor(r() * list2.length)], paint = 1 + Math.floor(r() * 8);
         if (!carModel(k, paint)) {
           if (origCar) origCar.f(M, A);
           return;
@@ -6050,14 +6329,14 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     const vegItem = (...a) => K.vegItem(...a);
     function houseItems() {
       const R = shared.ctx.r, T2 = shared.ctx.types, api = makeApi(), noModel = /* @__PURE__ */ new Map();
-      const list = R.items.concat(R.stateItems.filter((e) => e.w != null && e.d != null && e.type !== "razor_wire" && e.type !== "barbed_wire"));
+      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;
         for (let i = 0, j = poly.length - 1; i < poly.length; j = i++) a += poly[j][0] * poly[i][1] - poly[i][0] * poly[j][1];
         const xs = poly.map((p) => p[0]), zs = poly.map((p) => p[1]);
         return Math.abs(a) / 2 > 0.98 * (Math.max(...xs) - Math.min(...xs)) * (Math.max(...zs) - Math.min(...zs));
       };
-      for (const m of list) {
+      for (const m of list2) {
         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;
@@ -6111,19 +6390,19 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       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));
       cursor.group = slab ? "f" + f : "attic_tank";
       if (lc) {
-        const P = cd.platform, [x0, z0, x1, z1] = P.aabb, e = P.thickness, color = shared.ctx.colors.slab != null ? shared.ctx.colors.slab : 12170668;
+        const P = cd.platform, [x0, z0, x1, z1] = P.aabb, e = P.thickness, color2 = shared.ctx.colors.slab != null ? shared.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, color, 0, 0, 0);
+        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) => {
           cursor.pc = structurePiece("tank_column_" + k);
-          boxC("plain", p.u, (P.baseY + P.topY - e) / 2, p.v, p.side, P.topY - e - P.baseY, p.side, color, 0, 0, 0);
+          boxC("plain", p.u, (P.baseY + P.topY - e) / 2, p.v, p.side, P.topY - e - P.baseY, p.side, color2, 0, 0, 0);
         });
         cursor.pc = null;
       }
       if (!slab) {
-        const color = 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;
-        boxC("plain", cd.u, base - 0.06, cd.v, hw * 2, 0.12, hd * 2, color);
-        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, color);
+        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;
+        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 };
@@ -6135,8 +6414,8 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       return _col.setHSL((h >>> 0) % 360 / 360, 0.45, 0.55).getHex();
     }
     function labeledBox(m, M, group) {
-      const color = 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, color, 0, m.ry || 0, 0);
+      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" });
     }
     Object.assign(K, { houseItems, waterTankOfHouse, hashColor, labeledBox });
@@ -6650,10 +6929,10 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       if (!lt) return;
       const cz0 = (lt.rect[1] + lt.rect[3]) / 2;
       const orig = K.getBx(), gs = lt.gates, opening = gs.map((g) => g.open), reg = gs.map((g) => {
-        const color = g.model === "sliding", dx = color ? slideDirection(g, lt) : 0, a = g.u - g.width / 2, b = g.u + g.width / 2, zc = g.v + (cz0 - g.v >= 0 ? 1 : -1) * 0.19;
-        return { g, a, b, v: g.v, x0: Infinity, x1: -Infinity, y1: 0, color, dx, zc, lo: color ? dx > 0 ? a + 0.04 : a - 0.9 : a + 0.05, hi: color ? dx > 0 ? b + 0.9 + 0.01 : b - 0.04 : b + 0.01, zv: color ? 0.07 : 0.04, zm: color ? zc : g.v };
+        const color2 = g.model === "sliding", dx = color2 ? slideDirection(g, lt) : 0, a = g.u - g.width / 2, b = g.u + g.width / 2, zc = g.v + (cz0 - g.v >= 0 ? 1 : -1) * 0.19;
+        return { g, a, b, v: g.v, x0: Infinity, x1: -Infinity, y1: 0, color: color2, dx, zc, lo: color2 ? dx > 0 ? a + 0.04 : a - 0.9 : a + 0.05, hi: color2 ? dx > 0 ? b + 0.9 + 0.01 : b - 0.04 : b + 0.01, zv: color2 ? 0.07 : 0.04, zm: color2 ? zc : g.v };
       });
-      K.setBx(function(mat, x0, y0, z0, x1, y1, z1, color) {
+      K.setBx(function(mat, x0, y0, z0, x1, y1, z1, color2) {
         if (mat === "metal") {
           for (const r of reg) if (r.g.axis === "u" && x0 >= r.lo && x1 <= r.hi && z0 >= r.zm - r.zv && z1 <= r.zm + r.zv && y0 >= 0.03) {
             r.x0 = Math.min(r.x0, x0);
@@ -6661,12 +6940,12 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
             r.y1 = Math.max(r.y1, y1);
             const g0 = cursor.group;
             cursor.group = "ix:gate:" + r.g.id;
-            orig(mat, x0, y0, z0, x1, y1, z1, color);
+            orig(mat, x0, y0, z0, x1, y1, z1, color2);
             cursor.group = g0;
             return;
           }
         }
-        return orig(mat, x0, y0, z0, x1, y1, z1, color);
+        return orig(mat, x0, y0, z0, x1, y1, z1, color2);
       });
       const n0 = shared.ctx.colliders.length;
       try {
@@ -6741,10 +7020,10 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         else bx("plain", Math.min(f2, f3), yc - 0.032, u - 0.016, Math.max(f2, f3), yc + 0.032, u + 0.016, 16250092);
         cursor.group = g0;
         const pv = alongU ? [u, yc, f2] : [f2, yc, u];
-        const piece = 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 });
-        piece.t = piece.target = lightOn(roomId) ? 1 : 0;
+        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: [piece], text: () => t(lightOn(roomId) ? "prompt.lightOff" : "prompt.lightOn"), action: () => toggleLight(roomId) });
+        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) });
         return true;
       }
       return false;
@@ -6914,11 +7193,11 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     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);
-    function ivAccumulate(mat, g, ox, oy, oz, ry, color) {
-      const P = g.attributes.position, N = g.attributes.normal, C = color == null ? g.attributes.color : null, U = g.attributes.uv, I = g.index, nv = P.count, ni = I ? I.count : nv;
+    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);
       A.ensure(nv, ni);
-      const c = Math.cos(ry), s = Math.sin(ry), b = A.nv, rgb = color != null ? rgbOf(color) : [1, 1, 1];
+      const c = Math.cos(ry), s = Math.sin(ry), b = A.nv, rgb = color2 != null ? rgbOf(color2) : [1, 1, 1];
       for (let k = 0; k < nv; k++) {
         const x = P.getX(k), y = P.getY(k), z = P.getZ(k), o = b + k;
         A.p[o * 3] = x * c + z * s + ox;
@@ -6959,14 +7238,14 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     function ivBuild(h, water) {
       const ik = K.IVK, r = shared.ctx.r, A = ik.A, world0 = null;
       void world0;
-      const plane = A.plan(r, { seed: r.seed });
-      const IV = { k: ik, plane, 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 };
+      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 };
       h.IV = IV;
       const t0 = performance.now();
-      const lamps = new Set(plane.items.filter((e) => e.type === "lamp").map((e) => e.id));
-      for (const id of plane.mapped) if (!lamps.has(id)) IV.replace.add(id);
+      const lamps = new Set(plane2.items.filter((e) => e.type === "lamp").map((e) => e.id));
+      for (const id of plane2.mapped) if (!lamps.has(id)) IV.replace.add(id);
       const furnitureById = new Map(r.items.map((m) => [m.id, m]));
-      for (const e of plane.items) {
+      for (const e of plane2.items) {
         if (e.type !== "lamp") continue;
         const m = furnitureById.get(e.id);
         if (!m || !LIGHT_TYPES.has(m.type) || !m.room) continue;
@@ -6976,9 +7255,9 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         IV.lampRoom.set(e.id, m.room);
       }
       const wants = (roomId) => lightBase(roomId);
-      const entById = new Map(plane.items.map((e) => [e.id, e]));
-      const entByItem = new Map(plane.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.floorKind };
+      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 };
       const ev = (e) => ivEvent(h, e);
       const world = IV.world = A.createWorld(r, { water, seed: r.seed, onEvent: ev });
       const add0 = world.add;
@@ -6997,10 +7276,10 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         }
         return add0(id, spec, tr);
       };
-      const exitPoint = A.add(world, plane, { isBlocked: A.blockedOf(r), build: (type, item) => ivDraw(IV, entByItem.get(item), type, item) });
+      const added = A.add(world, plane2, { isBlocked: A.blockedOf(r), build: (type, item) => ivDraw(IV, entByItem.get(item), type, item) });
       world.add = add0;
-      IV.warnings = exitPoint.warnings;
-      IV.exitPoint = exitPoint;
+      IV.warnings = added.warnings;
+      IV.added = added;
       if (h.state.iv) {
         try {
           const st = JSON.parse(JSON.stringify(h.state.iv));
@@ -7023,7 +7302,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
           console.warn("interactables: state", err);
         }
       }
-      for (const e of plane.items) if (e.type === "wall_switch") for (const l of e.connections.controls || []) {
+      for (const e of plane2.items) if (e.type === "wall_switch") for (const l of e.connections.controls || []) {
         const roomId = IV.lampRoom.get(l);
         if (roomId) {
           IV.switchRooms.add(roomId);
@@ -7050,7 +7329,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       for (const l of out.lights) l.removeFromParent();
       const group = ivGroup(ent), g0 = cursor.group, root = new THREE.Group();
       root.name = "iv:" + ent.id;
-      root.position.set(item.x, ent.floorKind, item.z);
+      root.position.set(item.x, ent.floorY, item.z);
       root.rotation.y = item.ry;
       root.userData.iv = ent.id;
       const screen = spec.devices && spec.devices.some((d) => d.kind === "screen");
@@ -7074,7 +7353,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
               root.add(m);
               continue;
             }
-            ivAccumulate(IV_MATERIAL[m.userData.material] || "plain", m.geometry, item.x, ent.floorKind, item.z, item.ry, null);
+            ivAccumulate(IV_MATERIAL[m.userData.material] || "plain", m.geometry, item.x, ent.floorY, item.z, item.ry, null);
             m.geometry.dispose();
           } else root.add(m);
         }
@@ -7095,17 +7374,17 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
           roomLightMask(m);
         }
       });
-      const E = { id: ent.id, type, entry: ent, floor: ent.floor, group, root, parts: out.parts, spec, screen: body, pos: [item.x, ent.floorKind, item.z], ry: item.ry, origin: ent.origin };
+      const E = { id: ent.id, type, entry: ent, floor: ent.floor, group, root, parts: out.parts, spec, screen: body, pos: [item.x, ent.floorY, item.z], ry: item.ry, origin: ent.origin };
       IV.entries.set(ent.id, E);
       if (root.children.length) IV.roots.push(E);
       return spec;
     }
     function ivCords(IV) {
       const ik = IV.k, w = IV.world, wl = (o, p) => ik.GI.localToWorld(o.transform, p), g0 = cursor.group;
-      const tube = (pts, radius, color, ox, oy, oz, ry) => {
+      const tube = (pts, radius, color2, ox, oy, oz, ry) => {
         try {
           const m = ik.gfx.createCord(pts, radius, shared.mats.plain);
-          ivAccumulate("plain", m.geometry, ox, oy, oz, ry, color);
+          ivAccumulate("plain", m.geometry, ox, oy, oz, ry, color2);
           m.geometry.dispose();
         } catch (e) {
         }
@@ -7288,7 +7567,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     function ivItems(IV, h) {
       IV.itemsDirty = false;
       IV.itemsT = IV.t;
-      const w = IV.world, items = IV.k.A.household.items, f = IV.focus, g0 = cursor.group, list = [];
+      const w = IV.world, items = IV.k.A.household.items, f = IV.focus, g0 = cursor.group, list2 = [];
       let fl = null;
       if (f) {
         h.houseGroup.updateWorldMatrix(true, false);
@@ -7302,23 +7581,23 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
           if (c.access && w.partT(E.id, c.access) < 0.02) continue;
           const st = w.contents(E.id, c.id);
           for (let i = 0; i < st.length; i++) {
-            if (st[i] && items[st[i].type]) list.push([E, c.id, i, items[st[i].type]]);
+            if (st[i] && items[st[i].type]) list2.push([E, c.id, i, items[st[i].type]]);
           }
         }
       }
-      if (!list.length) {
+      if (!list2.length) {
         if (IV.items) IV.items.visible = false;
         return;
       }
       cursor.group = "iv-items";
       try {
-        for (const [E, cid, slot, def] of list) {
+        for (const [E, cid, slot, def] of list2) {
           const p = w.slotPosition(E.id, cid, slot), form = IV_SHAPE[def.shape] || IV_SHAPE.box;
           for (const [geo, fx, fy, fz, y0, tone] of form) {
             const sx = def.size[0] * fx, sy = def.size[1] * fy, sz = def.size[2] * fz;
             _q.setFromAxisAngle(_Y, E.ry);
-            const color = def.color == null ? 13421772 : def.color;
-            put("plain", geo, p[0], p[1] + def.size[1] * y0 + sy / 2, p[2], _q, sx, sy, sz, tone === 1 ? color : sh(color, tone));
+            const color2 = def.color == null ? 13421772 : def.color;
+            put("plain", geo, p[0], p[1] + def.size[1] * y0 + sy / 2, p[2], _q, sx, sy, sz, tone === 1 ? color2 : sh(color2, tone));
           }
         }
         const A = cursor.accs.get("iv-items|plain");
@@ -7443,7 +7722,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         })),
         seatInfo: () => ivSeat(IV),
         // {object, seat, pose: 'sit'|'lie', eye, yaw, pitch, exit, floor} if the player is sitting/lying
-        sit: com((object, seatInfo) => !!w.sit(object, seatInfo, "player")),
+        sit: com((object2, seatInfo) => !!w.sit(object2, seatInfo, "player")),
         stand: com(() => w.stand("player")),
         opens: com((mid, target) => {
           for (const E of IV.entries.values()) if (E.origin === mid) {
@@ -7454,7 +7733,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         breaker: com((circuit, on) => {
           if (on === void 0) return w.power.breaker(circuit);
           w.power.setBreaker(circuit, !!on);
-          const q = IV.plane.picture && IV.entries.get(IV.plane.picture);
+          const q = IV.plane.panel && IV.entries.get(IV.plane.panel);
           if (q && q.parts["breaker_" + circuit]) w.setPart(q.id, "breaker_" + circuit, on ? 1 : 0);
           IV.dirty = true;
           return !!on;
@@ -7523,6 +7802,1345 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     Object.assign(K, { props, TYPES, newState, enter, tagDamage });
   }
 
+  // ../game-floorplan-interactables/dist/index.js
+  var en2 = {
+    "error.missingKit": "game-floorplan-interactables: create needs GameInteractables and GameInteractablesHousehold",
+    "error.unknownOwnType": "game-floorplan-interactables: unknown own type: {type}",
+    "warn.cylinderNoCabinet": "cylinder {id} under the counter has no kitchen cabinet to hide it",
+    "warn.cabinetNoDoor": "cabinet {cabinet} has no door for the cylinder {id}",
+    "warn.switchUnknownLamp": "switch {id} controls {lamp}, which does not exist",
+    "warn.pointNoObject": "point {id} ({kind}) has no object for {item}",
+    "warn.buildEmpty": "build returned nothing for {id}"
+  };
+  var ptBR2 = {
+    "error.missingKit": "game-floorplan-interactables: create precisa de GameInteractables e GameInteractablesHousehold",
+    "error.unknownOwnType": "game-floorplan-interactables: tipo pr\xF3prio desconhecido: {type}",
+    "warn.cylinderNoCabinet": "botij\xE3o {id} sob a bancada sem arm\xE1rio de cozinha para escond\xEA-lo",
+    "warn.cabinetNoDoor": "arm\xE1rio {cabinet} sem porta para o botij\xE3o {id}",
+    "warn.switchUnknownLamp": "interruptor {id} controla {lamp}, que n\xE3o existe",
+    "warn.pointNoObject": "ponto {id} ({kind}) sem objeto para {item}",
+    "warn.buildEmpty": "construir devolveu vazio para {id}"
+  };
+  function createTranslator2(locale, table) {
+    const base = locale && /^pt/i.test(locale) ? ptBR2 : en2;
+    const messages = { ...base, ...table ?? {} };
+    return (key, params) => (messages[key] ?? key).replace(/\{(\w+)\}/g, (_m, name) => params && params[name] !== void 0 ? String(params[name]) : `{${name}}`);
+  }
+  var TYPE_MAP = Object.freeze({
+    fridge: { type: "fridge" },
+    // was `geladeira`
+    fridge_large: { type: "fridge" },
+    // was `geladeira2`
+    display_fridge_medium: { type: "fridge", variant: "steel" },
+    // was `geladeira_med`
+    display_fridge: { type: "fridge", variant: "steel" },
+    // was `refrig_exp`
+    freezer: { type: "fridge_compact" },
+    // was `freezer`
+    kitchen_cabinet: { compound: "sink" },
+    // was `armario_cozinha`
+    kitchen_cabinet_small: { compound: "sink" },
+    // was `armario_cozinha_p`
+    kitchen_cabinet_large: { compound: "sink" },
+    // was `armario_cozinha_g`
+    washbasin: { compound: "basin" },
+    // was `pia_b`
+    pedestal_basin: { compound: "basin" },
+    // was `pia_coluna`
+    wardrobe: { type: "wardrobe" },
+    // was `guarda`
+    wardrobe_small: { type: "wardrobe" },
+    // was `guarda_peq`
+    wardrobe_large: { type: "wardrobe" },
+    // was `guarda_g`
+    closet_wardrobe: { type: "wardrobe" },
+    // was `guarda_closet`
+    dresser: { type: "dresser" },
+    // was `comoda`
+    nightstand: { type: "nightstand" },
+    // was `criado`
+    pantry: { type: "pantry" },
+    // was `despensa`
+    laundry_cabinet: { type: "pantry" },
+    // was `armario_lav`
+    china_cabinet: { type: "pantry" },
+    // was `cristaleira`
+    filing_cabinet: { type: "dresser" },
+    // was `arquivo`
+    console_table: { type: "dresser" },
+    // was `aparador_c`
+    tv_unit: { type: "kitchen_cabinet_base" },
+    // was `rack`
+    tv_unit_small: { type: "kitchen_cabinet_base" },
+    // was `rack_peq`
+    tv_unit_large: { type: "kitchen_cabinet_base" },
+    // was `rack_grande`
+    stove: { type: "stove" },
+    // was `fogao`
+    stove_4burner: { type: "stove" },
+    // was `fogao4`
+    cooking_gas_cylinder: { type: "gas_bottle", dim: "none" },
+    // was `botijao_gas`
+    gas_cylinder: { type: "gas_bottle", dim: "none" },
+    // was `botijao`
+    tv: { type: "tv" },
+    // was `tv`
+    tv_large: { type: "tv" },
+    // was `tv_grande`
+    microwave: { type: "microwave" },
+    // was `microondas`
+    washing_machine: { type: "washing_machine" },
+    // was `maquina`
+    shower: { type: "shower", dim: "wd" },
+    // was `box`
+    shower_large: { type: "shower", dim: "wd" },
+    // was `box_g`
+    toilet: { type: "toilet", dim: "wd" },
+    // was `vaso`
+    laundry_tub: { type: "utility_sink", dim: "wd" },
+    // was `tanque`
+    sofa_2seat: { type: "sofa" },
+    // was `sofa2`
+    sofa_3seat: { type: "sofa" },
+    // was `sofa3`
+    sofa_l: { type: "sofa" },
+    // was `sofa_l`
+    sofa_xl: { type: "sofa" },
+    // was `sofa_xl`
+    armchair: { type: "armchair" },
+    // was `poltrona`
+    armchair_high: { type: "armchair" },
+    // was `poltrona_alta`
+    stool: { type: "dining_chair" },
+    // was `banqueta`
+    camp_chair: { type: "camp_chair", dim: "wd" },
+    // was `cadeira_camping`
+    rocking_chair: { type: "armchair" },
+    // was `cadeira_balanco`
+    rustic_sink: { compound: "rustic_sink" },
+    // was `pia_rustica`: the sink of the cabin or shack: the basin the whole width, no cabinet under it; a wall cabinet only if there is `overhead` content
+    improvised_bed: { type: "bed_single", dim: "wd" },
+    // was `cama_improvisada`
+    log_bench: { type: "bench", dim: "wd" },
+    // was `banco_tronco`
+    plank_shelf: { type: "pantry", variant: "garage" },
+    // was `prateleira_tabua`
+    sideboard: { type: "dresser" },
+    // was `aparador`
+    buffet: { type: "dresser" },
+    // was `bufe`
+    single_bed: { type: "bed_single", dim: "wd" },
+    // was `cama_solteiro`
+    double_bed: { type: "bed_double", dim: "wd" },
+    // was `cama_casal`
+    queen_bed: { type: "bed_double", dim: "wd" },
+    // was `cama_queen`
+    king_bed: { type: "bed_double", dim: "wd" },
+    // was `cama_king`
+    bench: { type: "bench", dim: "wd" },
+    // was `banco`
+    garden_bench: { type: "bench", dim: "wd" },
+    // was `banco_jardim`
+    waiting_bench: { type: "bench", dim: "wd" },
+    // was `espera`
+    blinds: { type: "blinds" },
+    // was `persiana`
+    curtain: { type: "curtain" },
+    // was `cortina`
+    trash_bin: { type: "trash_bin" },
+    // was `lixeira`
+    outdoor_bin: { type: "wheelie_bin" },
+    // was `lixeira_ext`
+    mailbox: { type: "mailbox", dim: "none" },
+    // was `caixa_correio`: the household draws the box on its post: position and rotation only
+    doghouse: { type: "dog_house" },
+    // was `casinha_cachorro`
+    bbq_grill: { type: "bbq", dim: "wd" },
+    // was `churrasqueira`
+    bbq_simple: { type: "bbq", dim: "wd" },
+    // was `churrasqueira_simples`
+    clothesline: { type: "clothesline", dim: "wh" },
+    // was `varal`
+    tool_shelf: { type: "pantry", variant: "garage" },
+    // was `estante_ferr`
+    workbench: { type: "pantry", variant: "garage" },
+    // was `bancada_ferr`
+    // rural houses and campsite (types of the household pack: rural and camp)
+    bunk_bed: { type: "bunk_bed", dim: "wd" },
+    // was `beliche`
+    wood_stove: { type: "wood_stove", dim: "wd" },
+    // was `fogao_lenha`: the flue rises to the chimney height (cabin); the fireplace is handled in `planSimple` (it moves and changes height)
+    fireplace: { type: "fireplace", dim: "w" },
+    // was `lareira`
+    outhouse: { type: "outhouse", dim: "wdh" },
+    // was `privada`
+    well: { type: "well", dim: "none" },
+    // was `poco`
+    cooler: { type: "cooler", dim: "wd" },
+    // was `cooler`
+    campfire: { type: "campfire", dim: "wd" },
+    // was `fogueira`
+    camp_stove: { type: "camp_stove", dim: "wd" },
+    // was `fogareiro`
+    camp_gas_canister: { type: "gas_canister", dim: "none" },
+    // was `botijao_camping`
+    camp_table: { type: "camp_table", dim: "wdh" },
+    // was `mesa_camping`
+    // kerosene/gas lanterns: a `lamp` device without electricity (the grid does not matter); the ceiling one is the `hanging` variant
+    oil_lamp: { type: "lantern_lamp", dim: "x" },
+    // was `lampiao`
+    camp_lantern: { type: "lantern_lamp", dim: "x" },
+    // was `lampiao_camping`
+    ceiling_oil_lamp: { type: "lantern_lamp", variant: "hanging", dim: "x" },
+    // was `lampiao_teto`
+    // lamps: objects of the adapter (the kit has no lamp mesh; the house renderer draws the fixture)
+    ceiling_light: { type: "lamp", watts: 15 },
+    // was `plafon`
+    pendant: { type: "lamp", watts: 20 },
+    // was `pendente`
+    track_spot: { type: "lamp", watts: 10 },
+    // was `spot_trilho`
+    chandelier: { type: "lamp", watts: 60 },
+    // was `lustre`
+    floor_lamp: { type: "lamp", watts: 12 },
+    // was `luminaria`
+    table_lamp: { type: "lamp", watts: 9 }
+    // was `abajur`
+  });
+  var CHAIR_TABLES = Object.freeze({
+    dining_table: "dining",
+    // was `mesa`
+    dining_table_small: "dining",
+    // was `mesa_peq`
+    dining_table_round: "dining",
+    // was `mesa_red`
+    dining_table_large: "dining",
+    // was `mesa_grande`
+    gourmet_table: "dining",
+    // was `mesa_gourmet`
+    gourmet_table_small: "dining",
+    // was `mesa_gourmet_peq`
+    outdoor_table: "dining",
+    // was `mesa_ext`
+    office_desk: "office",
+    // was `mesa_escr`
+    office_desk_large: "office",
+    // was `mesa_escr_g`
+    desk: "office"
+    // was `escrivaninha`
+  });
+  var DINING_CHAIR_SIDE = 0.45;
+  var CONTENT_MAP = Object.freeze({
+    // food
+    sugar: "sugar",
+    // was `acucar`
+    rice: "rice",
+    // was `arroz`
+    biscuits: "biscuits",
+    // was `biscoito`
+    coffee: "coffee",
+    // was `cafe`
+    raw_beef: "frozen_meat",
+    // was `carne`
+    packed_meat: "frozen_meat",
+    // was `carne`
+    flour: "flour",
+    // was `farinha`
+    beans: "beans",
+    // was `feijao`
+    apple: "apple",
+    // was `fruta`
+    fruit: "apple",
+    // was `fruta`
+    yogurt: "yogurt",
+    // was `iogurte`
+    canned_food: "canned_food",
+    // was `lata_atum`
+    canned_tuna: "canned_food",
+    // was `lata_atum`
+    canned_corn_and_peas: "canned_food",
+    // was `lata_milho`
+    canned_corn: "canned_food",
+    // was `lata_milho`
+    milk_carton: "milk_carton",
+    // was `leite`
+    pasta: "pasta",
+    // was `macarrao`
+    cooking_oil: "cooking_oil",
+    // was `oleo`
+    eggs: "eggs",
+    // was `ovos`
+    cheese: "cheese",
+    // was `queijo`
+    leftover_meal: "bowl",
+    // was `sobras`
+    leftovers: "bowl",
+    // was `sobras`
+    ice_cream: "ice_cream",
+    // was `sorvete`
+    seasoning: "salt",
+    // was `tempero`
+    spices: "salt",
+    // was `tempero`
+    // water and drink
+    water_jug_5l: "water_bottle",
+    // was `agua_galao`
+    water_jug: "water_bottle",
+    // was `agua_galao`
+    water_bottle: "water_bottle",
+    // was `agua_garrafa`
+    soda_can: "soda_can",
+    // was `refrigerante`
+    soda: "soda_can",
+    // was `refrigerante`
+    // medicine
+    alcohol_70: "alcohol_70",
+    // was `alcool`
+    rubbing_alcohol: "alcohol_70",
+    // was `alcool`
+    adhesive_bandages: "bandage",
+    // was `curativo`
+    bandages: "bandage",
+    // was `curativo`
+    insulin: "first_aid_kit",
+    // was `insulina`
+    painkillers: "painkillers",
+    // was `paracetamol`
+    painkiller: "painkillers",
+    // was `paracetamol`
+    maintenance_medication: "painkillers",
+    // was `remedio`
+    medicine: "painkillers",
+    // was `remedio`
+    // cleaning and hygiene
+    bleach: "bleach",
+    // was `agua_sanitaria`
+    disinfectant: "bleach",
+    // was `desinfetante`
+    detergent: "detergent",
+    // was `detergente`
+    dish_soap: "detergent",
+    // was `detergente`
+    toothbrush: "toothbrush",
+    // was `escova_dente`
+    sponge: "sponge",
+    // was `esponja`
+    rubber_gloves: "sponge",
+    // was `luvas`
+    toilet_paper: "toilet_paper",
+    // was `papel_higienico`
+    laundry_powder: "detergent",
+    // was `sabao_po`
+    washing_powder: "detergent",
+    // was `sabao_po`
+    soap: "soap",
+    // was `sabonete`
+    shampoo: "shampoo",
+    // was `shampoo`
+    // clothes
+    jeans: "jeans",
+    // was `calca`
+    trousers: "jeans",
+    // was `calca`
+    tshirt: "tshirt",
+    // was `camisa`
+    shirt: "tshirt",
+    // was `camisa`
+    t_shirt: "tshirt",
+    // was `camiseta`
+    jacket: "jacket",
+    // was `casaco`
+    coat: "jacket",
+    // was `casaco`
+    blanket: "blanket",
+    // was `cobertor`
+    socks: "socks",
+    // was `meias`
+    underwear: "underwear",
+    // was `roupa_intima`
+    sneakers: "sneakers",
+    // was `sapato`
+    shoes: "sneakers",
+    // was `sapato`
+    // utensils
+    cup: "cup",
+    // was `caneca`
+    mug: "cup",
+    // was `caneca`
+    plate: "plate",
+    // was `prato`
+    china_plates: "plate",
+    // was `prato`
+    plates: "plate",
+    // was `prato`
+    wine_glass: "cup",
+    // was `taca`
+    wine_glasses: "cup",
+    // was `taca`
+    pot: "pot",
+    // was `panela`
+    // tools and electronics
+    pliers: "screwdriver",
+    // was `alicate`
+    bucket: "paint_can",
+    // was `balde`
+    cable_bundle: "phone_charger",
+    // was `cabos`
+    cables: "phone_charger",
+    // was `cabos`
+    pen: "pen",
+    // was `caneta`
+    phone_charger: "phone_charger",
+    // was `carregador`
+    charger: "phone_charger",
+    // was `carregador`
+    screwdriver: "screwdriver",
+    // was `chave_fenda`
+    house_key: "wallet",
+    // was `chaves`
+    keys: "wallet",
+    // was `chaves`
+    remote_control: "batteries",
+    // was `controle_remoto`
+    rope: "rope",
+    // was `corda`
+    electrical_tape: "duct_tape",
+    // was `fita_isolante`
+    insulating_tape: "duct_tape",
+    // was `fita_isolante`
+    flashlight: "flashlight",
+    // was `lanterna`
+    backpack: "backpack",
+    // was `mochila`
+    eyeglasses: "wallet",
+    // was `oculos`
+    glasses: "wallet",
+    // was `oculos`
+    screws: "duct_tape",
+    // was `parafusos`
+    batteries: "batteries",
+    // was `pilhas`
+    nails: "duct_tape",
+    // was `pregos`
+    // improvised weapons
+    knife: "knife",
+    // was `faca`
+    kitchen_knife: "knife",
+    // was `faca`
+    stapler: "scissors",
+    // was `grampeador`
+    hammer: "hammer",
+    // was `martelo`
+    handsaw: "hammer",
+    // was `serrote`
+    hand_saw: "hammer",
+    // was `serrote`
+    scissors: "scissors",
+    // was `tesoura`
+    broom: "rope",
+    // was `vassoura`
+    // papers
+    letter: "letter",
+    // was `carta`
+    bill: "bill",
+    // was `conta`
+    documents: "documents",
+    // was `documento`
+    dvd: "notebook",
+    // was `dvd`
+    dvds: "notebook",
+    // was `dvd`
+    book: "notebook",
+    // was `livro`
+    // trash
+    food_packaging: "plastic_bag",
+    // was `embalagem`
+    packaging: "plastic_bag",
+    // was `embalagem`
+    paint_can: "paint_can",
+    // was `lata_tinta`
+    empty_can: "empty_can",
+    // was `lata_vazia`
+    flyer: "flyer",
+    // was `panfleto`
+    crumpled_paper: "crumpled_paper",
+    // was `papel_amassado`
+    trash_bag: "plastic_bag",
+    // was `saco_lixo`
+    full_trash_bag: "plastic_bag"
+    // was `saco_lixo_cheio`
+  });
+  var CONTENT_BY_GROUP = Object.freeze({
+    food: "canned_food",
+    // was `comida`
+    water: "water_bottle",
+    // was `agua`
+    medicine: "painkillers",
+    // was `remedio`
+    tool: "duct_tape",
+    // was `ferramenta`
+    improvised_weapon: "hammer",
+    // was `arma_improvisada`
+    clothes: "tshirt",
+    // was `roupa`
+    document: "documents",
+    // was `documento`
+    cleaning: "detergent",
+    // was `limpeza`
+    trash: "crumpled_paper",
+    // was `lixo`
+    utensil: "plate"
+    // was `utensilio`
+  });
+  var CONTENT_FALLBACK = "crumpled_paper";
+  var FROZEN_ITEMS = Object.freeze(["ice_cream", "frozen_meat"]);
+  var DRAWER_ITEMS = Object.freeze(["underwear", "socks"]);
+  var DRAWER_GROUPS = Object.freeze(["improvised_weapon", "tool"]);
+  var OBJECT_SUBSTITUTES = Object.freeze({ mailbox: ["flyer", "postcard", "letter"] });
+  var FIXTURES_OF_POINT = Object.freeze({
+    tap: ["tap"],
+    // was `torneira`
+    shower: ["shower"],
+    // was `chuveiro`
+    flush: ["flush"],
+    // was `descarga`
+    tub: ["tap", "basin"],
+    // was `tanque`
+    machine: ["inlet"]
+    // was `maquina`
+  });
+  var OWN_TYPES = Object.freeze({ lamp: true, gas_piped: true });
+  var ADAPTER_VERSION = "0.3.0";
+  var r3 = (n) => Math.round(n * 1e3) / 1e3;
+  function mergeRegistry(base, extra) {
+    const out = { ...base };
+    if (extra) {
+      for (const [key, value] of Object.entries(extra)) {
+        if (value == null) delete out[key];
+        else out[key] = value;
+      }
+    }
+    return out;
+  }
+  var PREFERENCE = Object.freeze({
+    fridge: (s, c) => c.frozen(s) ? ["freezer", "fridge"] : ["fridge", "freezer"],
+    fridge_compact: (s, c) => c.frozen(s) ? ["freezer", "fridge"] : ["fridge", "freezer"],
+    kitchen_cabinet_base: (s, c) => DRAWER_GROUPS.includes(c.group(s)) ? ["drawer", "cupboard"] : ["cupboard", "drawer"],
+    wardrobe: (s, c) => c.drawerItem(s) ? ["drawer_1", "drawer_2", "drawer_3", "shelves"] : ["shelves", "drawer_1", "drawer_2", "drawer_3"]
+  });
+  function create2(options = {}) {
+    const opts = options || {};
+    const GI = opts.GameInteractables;
+    const HH = opts.GameInteractablesHousehold;
+    const locale = opts.locale || "pt-BR";
+    const msg = createTranslator2(locale, opts.messages);
+    if (!GI || !HH) throw new Error(msg("error.missingKit"));
+    const region = opts.region || "br";
+    const hh = HH.createHousehold({ locale, region });
+    const householdTypes = new Set(hh.types.map((t) => t.id));
+    const worlds = /* @__PURE__ */ new WeakMap();
+    const typeMap = mergeRegistry(TYPE_MAP, opts.typeMap);
+    const contentMap = mergeRegistry(CONTENT_MAP, opts.contentMap);
+    const contentByGroup = mergeRegistry(CONTENT_BY_GROUP, opts.contentByGroup);
+    const chairTables = mergeRegistry(CHAIR_TABLES, opts.chairTables);
+    const fixturesOfPoint = mergeRegistry(FIXTURES_OF_POINT, opts.fixturesOfPoint);
+    const substitutes = mergeRegistry(OBJECT_SUBSTITUTES, opts.substitutes);
+    const preference = mergeRegistry(PREFERENCE, opts.preference);
+    const ownTypes = mergeRegistry(OWN_TYPES, opts.ownTypes);
+    const frozenItems = new Set(opts.frozenItems ?? FROZEN_ITEMS);
+    const drawerItems = new Set(opts.drawerItems ?? DRAWER_ITEMS);
+    const chairSide = opts.chairSide ?? DINING_CHAIR_SIDE;
+    const contentFallback = opts.contentFallback ?? CONTENT_FALLBACK;
+    const seedKey = (id) => {
+      if (!opts.seedKey) return id;
+      const key = opts.seedKey(id);
+      return key == null ? id : key;
+    };
+    function conv(o) {
+      return {
+        x: (u) => r3(o.ox + u),
+        z: (v) => r3(o.oz + o.inw * v),
+        ry: (fu, fv) => r3(Math.atan2(fu, o.inw * fv)),
+        // local offset (lx, lz) of an object with rotation ry -> offset in the world (same convention as three.js)
+        off: (ry, lx, lz) => [Math.cos(ry) * lx + Math.sin(ry) * lz, -Math.sin(ry) * lx + Math.cos(ry) * lz]
+      };
+    }
+    function floorYOf(res, o, floor) {
+      if (floor == null || floor < 0) return o.base;
+      const f = (res.floors || []).find((x) => x.index === floor);
+      return r3(o.base + (f ? f.y0 : 0));
+    }
+    function colorOf(res, color2) {
+      if (color2 == null) return void 0;
+      if (typeof color2 === "number") return color2;
+      const v = res.colors && res.colors[color2];
+      return typeof v === "number" ? v : void 0;
+    }
+    function paletteOf(res) {
+      const c = res.colors || {};
+      const p = {};
+      if (c.wood != null) p.wood = c.wood;
+      if (c.fabric_main != null) p.fabric_main = c.fabric_main;
+      if (c.fabric_accent != null) p.fabric_accent = c.fabric_accent;
+      if (c.metal != null) p.metal = c.metal;
+      return p;
+    }
+    function lightsOfState(res) {
+      const electrical = res.utilities && res.utilities.electrical;
+      return res.state !== "abandoned" && !!electrical && electrical.mode !== "offgrid";
+    }
+    function initialLight(res, popts, id, entry2) {
+      const v = popts && popts.lightsOn;
+      if (typeof v === "function") return !!v(id, entry2);
+      if (typeof v === "boolean") return v;
+      return !!(popts && popts.night) && lightsOfState(res);
+    }
+    const stackGroup = (s) => s.group ?? (opts.groupOf ? opts.groupOf(s.itemId) : null) ?? null;
+    const preferenceContext = {
+      frozen: (s) => frozenItems.has(s.itemId),
+      group: stackGroup,
+      drawerItem: (s) => drawerItems.has(s.itemId)
+    };
+    const itemOfContent = (c) => {
+      const id = contentMap[c.itemId] || (hh.items[c.itemId] ? c.itemId : null) || contentByGroup[stackGroup(c)] || contentFallback;
+      return hh.items[id] ? id : contentFallback;
+    };
+    const volume = (d) => d.size[0] * d.size[1] * d.size[2];
+    const candidates = (id, objectType) => {
+      const def = hh.items[id];
+      const siblings = Object.values(hh.items).filter((i) => i.category === def.category && i.id !== id).sort((a, b) => volume(a) - volume(b) || (a.id < b.id ? -1 : 1));
+      return [id].concat(siblings.map((i) => i.id), substitutes[objectType] || []);
+    };
+    function distribute(type, probeItem, stacks) {
+      const spec = hh.build(type, probeItem, HH.createRecorder().api);
+      const conts = spec.containers || [];
+      const contents = {};
+      for (const c of conts) contents[c.id] = c.slots.map(() => null);
+      const rejected = [];
+      const pref = preference[type];
+      for (const p of stacks || []) {
+        const original = itemOfContent(p);
+        const order = (pref ? pref(p, preferenceContext) : []).concat(conts.map((c) => c.id));
+        let placed = false;
+        for (const id of candidates(original, type)) {
+          const def = hh.items[id];
+          const qty = Math.max(1, Math.min(p.count || 1, def && def.stack || 1));
+          for (const cid of order) {
+            const c = conts.find((x) => x.id === cid);
+            if (!c) continue;
+            for (let i = 0; i < c.slots.length && !placed; i++) {
+              if (contents[cid][i] || !GI.fitsSlot(id, c.slots[i], hh.items)) continue;
+              const data = { source: p.itemId, group: p.group, pickable: p.pickable !== false };
+              if (id !== original) data.substituteFor = original;
+              contents[cid][i] = { type: id, qty, data };
+              placed = true;
+            }
+            if (placed) break;
+          }
+          if (placed) break;
+        }
+        if (!placed) rejected.push(p);
+      }
+      return { contents, rejected };
+    }
+    function plan(res, popts = {}) {
+      popts = popts || {};
+      const o = { ox: popts.originX || 0, oz: popts.originZ || 0, inw: popts.inw || 1, base: popts.base || 0 };
+      const K = conv(o);
+      const floorSel = popts.floor;
+      const externals = popts.externals !== false;
+      const seed = popts.seed != null ? popts.seed : res.seed;
+      const palette = paletteOf(res);
+      const onFloor = (f, outdoor) => floorSel == null || f === floorSel || (outdoor || f < 0) && externals;
+      const utilities = res.utilities || {};
+      const electrical = utilities.electrical || null;
+      const circuits = electrical && electrical.circuits || [];
+      const contents = res.contents || {};
+      const result = {
+        version: ADAPTER_VERSION,
+        template: res.template,
+        seed: res.seed,
+        floor: floorSel == null ? null : floorSel,
+        items: [],
+        outlets: [],
+        // ids of the wall_socket entries
+        switches: [],
+        // ids of the wall_switch entries
+        lights: [],
+        // ids of the lamps (inside and outside)
+        lanterns: [],
+        // ids of the lanterns (lantern_lamp): kerosene/gas light, no grid
+        canisters: [],
+        // ids of the small camping cylinders (gas_canister)
+        serviceEntrance: null,
+        panel: null,
+        // id of the electrical_panel entry (distribution board)
+        meter: null,
+        // id of the power_meter entry (meter box on the facade or the pillar)
+        conduits: [],
+        cylinders: [],
+        // { id, stove, place }
+        stoves: [],
+        fixtures: [],
+        // { object, fixture, global, point, pointKind }
+        points: {},
+        // global fixture -> point of the plumbing
+        mapped: [],
+        // ids of furniture of the plan that became objects of the kit (the renderer does not need to draw them)
+        chairs: [],
+        // ids of the chairs the adapter put around the tables (origin = the table, which the renderer keeps drawing)
+        unmapped: {},
+        // "category/type" -> count
+        discarded: 0,
+        // stacks of content that fit no slot
+        warnings: [],
+        origin: { x: o.ox, z: o.oz, inw: o.inw, base: o.base }
+      };
+      const byOrigin = /* @__PURE__ */ new Map();
+      const seedOf2 = (id) => GI.hashString(String(seed) + ":" + seedKey(id));
+      function push(e) {
+        result.items.push(e);
+        if (!byOrigin.has(e.origin)) byOrigin.set(e.origin, []);
+        byOrigin.get(e.origin).push(e);
+        return e;
+      }
+      function baseItem(m) {
+        const item = {
+          x: K.x(m.x),
+          z: K.z(m.z),
+          ry: m.frontU != null ? K.ry(m.frontU, m.frontV) : r3(m.ry || 0),
+          w: m.w,
+          d: m.d,
+          h: m.h,
+          y: m.y || 0,
+          seed: seedOf2(m.id),
+          palette
+        };
+        const color2 = colorOf(res, m.color);
+        if (color2 != null) item.color = color2;
+        return item;
+      }
+      function entry2(id, type, item, origin, floor, extra) {
+        return Object.assign({ id, type, item, origin, floor, floorY: floorYOf(res, o, floor), connections: {} }, extra || {});
+      }
+      function store(targets, stacks) {
+        let rest = stacks || [];
+        for (const [type, item] of targets) {
+          const d = distribute(type, item, rest);
+          item.contents = Object.assign(item.contents || {}, d.contents);
+          rest = d.rejected;
+        }
+        result.discarded += rest.length;
+      }
+      const hidden = [];
+      function distRect(c, x, z) {
+        const dx = x - c.item.x;
+        const dz = z - c.item.z;
+        const s = Math.sin(c.item.ry);
+        const co = Math.cos(c.item.ry);
+        const lx = dx * co - dz * s;
+        const lz = dx * s + dz * co;
+        return Math.hypot(Math.max(Math.abs(lx) - (c.item.w || 0) / 2, 0), Math.max(Math.abs(lz) - (c.item.d || 0) / 2, 0));
+      }
+      function hideCylinders() {
+        for (const b of hidden) {
+          let target = null;
+          for (const c2 of result.items) {
+            if (c2.type !== "kitchen_cabinet_base" || c2.floor !== b.floor) continue;
+            const dist = distRect(c2, b.item.x, b.item.z);
+            if (!target || dist < target.dist) target = { c: c2, dist };
+          }
+          if (!target) {
+            result.warnings.push(msg("warn.cylinderNoCabinet", { id: b.id }));
+            continue;
+          }
+          const c = target.c;
+          const spec = hh.build(c.type, c.item, HH.createRecorder().api);
+          const sn = Math.sin(c.item.ry);
+          const cs = Math.cos(c.item.ry);
+          let door = null;
+          for (const it of spec.interactions || []) {
+            const pt = it.action && it.action.do === "toggle_part" ? (spec.parts || []).find((q) => q.id === it.action.part) : null;
+            if (!pt || pt.motion.kind !== "hinge") continue;
+            const wx = c.item.x + it.pos[0] * cs + it.pos[2] * sn;
+            const wz = c.item.z - it.pos[0] * sn + it.pos[2] * cs;
+            const dist = Math.hypot(wx - b.item.x, wz - b.item.z);
+            if (!door || dist < door.dist) door = { id: pt.id, dist };
+          }
+          if (!door) {
+            result.warnings.push(msg("warn.cabinetNoDoor", { cabinet: c.id, id: b.id }));
+            continue;
+          }
+          b.item.requires = { object: c.id, part: door.id };
+        }
+      }
+      function initialLanternLight(id, e) {
+        const v = popts.lightsOn;
+        if (typeof v === "function") return !!v(id, e);
+        if (typeof v === "boolean") return v;
+        return !!popts.night && res.state !== "abandoned";
+      }
+      const chimney = res.structureExtras && res.structureExtras.chimney || null;
+      const firstOfType = (type) => (res.items || []).find((m) => typeMap[m.type] && typeMap[m.type].type === type);
+      function chimneyOf(m, role) {
+        if (!chimney) return null;
+        const named = role === "fireplace" ? chimney.fireplace : chimney.stove;
+        if (named != null) return named === m.id ? chimney : null;
+        const first = firstOfType(role === "fireplace" ? "fireplace" : "wood_stove");
+        return chimney.kind === (role === "fireplace" ? "fireplace" : "flue") && first && first.id === m.id ? chimney : null;
+      }
+      const chimneyHeight = (ch) => ch.height != null ? ch.height : ch.top;
+      const campStove = firstOfType("camp_stove");
+      const campCylinder = firstOfType("gas_canister");
+      function planFireplace(m, e, item) {
+        const def = hh.types.find((t) => t.id === "fireplace");
+        const lack = (def.d - m.d) / 2;
+        item.x = r3(item.x + Math.sin(item.ry) * lack);
+        item.z = r3(item.z + Math.cos(item.ry) * lack);
+        const room = (res.rooms || []).find((c) => c.id === m.room && c.floor === m.floor);
+        const f = (res.floors || []).find((x) => x.index === m.floor);
+        item.h = r3(room && room.ceiling || f && f.ceiling || 2.6);
+        const ch = chimneyOf(m, "fireplace");
+        if (ch) {
+          if (ch.material === "stone") item.variant = "stone";
+          const cx = K.x((ch.aabb[0] + ch.aabb[2]) / 2);
+          const cz = K.z((ch.aabb[1] + ch.aabb[3]) / 2);
+          e.connections.chimneyTop = [cx, r3(o.base + chimneyHeight(ch)), cz];
+        }
+      }
+      function planSimple(m, map) {
+        const item = baseItem(m);
+        const dim = map.dim === "none" ? "" : map.dim || "wdh";
+        for (const k of ["w", "d", "h"]) if (dim.indexOf(k) < 0) delete item[k];
+        if (map.dim === "none") delete item.y;
+        if (map.variant) item.variant = map.variant;
+        if (map.type === "tv") item.d = Math.max(item.d || 0, 0.2);
+        const e = entry2(m.id, map.type, item, m.id, m.floor);
+        if (contents[m.id]) store([[map.type, item]], contents[m.id]);
+        if (m.outlet) e.connections.outlet = m.outlet;
+        if (map.type === "shower") e.connections.shower = m.showerHeater || { electric: false };
+        if (map.type === "stove") {
+          result.stoves.push(e.id);
+          e.connections.gas = m.gas || "cylinder";
+          e.connections.cylinder = m.cylinder || null;
+        }
+        if (map.type === "gas_bottle") result.cylinders.push({ id: e.id, stove: m.link || null, place: m.placement || null });
+        if (map.type === "gas_canister") {
+          result.canisters.push(e.id);
+          if (campCylinder && campCylinder.id === m.id && campStove) result.cylinders.push({ id: e.id, stove: campStove.id, place: null });
+        }
+        if (map.type === "wood_stove") {
+          const ch = chimneyOf(m, "stove");
+          if (ch && chimneyHeight(ch)) {
+            const f = (res.floors || []).find((x) => x.index === m.floor);
+            const high = r3(chimneyHeight(ch) - (f ? f.y0 : 0) - (m.y || 0));
+            item.h = high;
+            item.flueHeight = high;
+          }
+        }
+        if (map.type === "fireplace") planFireplace(m, e, item);
+        if (map.type === "lantern_lamp") {
+          e.lit = initialLanternLight(m.id, e);
+          item.on = e.lit;
+          result.lanterns.push(e.id);
+        }
+        if (map.type === "gas_bottle" && m.placement === "under_counter") hidden.push(e);
+        push(e);
+      }
+      function planCompound(m, kind) {
+        const ry = m.frontU != null ? K.ry(m.frontU, m.frontV) : r3(m.ry || 0);
+        const cx = K.x(m.x);
+        const cz = K.z(m.z);
+        const part = (id, type, w, d, h, y, lx, lz) => {
+          const [dx, dz] = K.off(ry, lx, lz);
+          const item = baseItem(m);
+          item.x = r3(cx + dx);
+          item.z = r3(cz + dz);
+          item.ry = ry;
+          item.w = r3(w);
+          item.d = r3(d);
+          item.h = r3(h);
+          item.y = y;
+          item.seed = seedOf2(id);
+          return entry2(id, type, item, m.id, m.floor);
+        };
+        const list2 = [];
+        const overhead = contents[m.id + "#overhead"];
+        if (kind === "rustic_sink") {
+          const dd = Math.max(m.d, 0.56);
+          const basin = part(m.id, "sink_kitchen", m.w, dd, m.h + 0.3, 0, 0, -(dd - m.d) / 2);
+          list2.push(basin);
+          const over = overhead || [];
+          if (m.overhead !== false && over.length) {
+            const wall = part(m.id + "#overhead", "kitchen_cabinet_wall", m.w, 0.35, 0.6, 1.55, 0, -(m.d / 2) + 0.175);
+            store([["kitchen_cabinet_wall", wall.item]], over);
+            list2.push(wall);
+          }
+          if (contents[m.id]) store([["sink_kitchen", basin.item]], contents[m.id]);
+          if (m.outlet) basin.connections.outlet = m.outlet;
+        } else if (kind === "sink") {
+          const width = m.w;
+          const basinW = width >= 1.5 ? 1 : Math.max(0.6, Math.min(0.8, width - 0.3));
+          const rest = r3(width - basinW);
+          const left = seedOf2(m.id) % 2 === 0;
+          const sink = part(m.id, "sink_kitchen", basinW, m.d, m.h + 0.25, 0, left ? -(width / 2) + basinW / 2 : width / 2 - basinW / 2, 0);
+          list2.push(sink);
+          let cabinet = null;
+          if (rest >= 0.35) {
+            cabinet = part(m.id + "#cabinet", "kitchen_cabinet_base", rest, m.d, m.h, 0, left ? width / 2 - rest / 2 : -(width / 2) + rest / 2, 0);
+            list2.push(cabinet);
+          }
+          if (contents[m.id]) store(cabinet ? [["kitchen_cabinet_base", cabinet.item], ["sink_kitchen", sink.item]] : [["sink_kitchen", sink.item]], contents[m.id]);
+          if (m.overhead !== false) {
+            const wall = part(m.id + "#overhead", "kitchen_cabinet_wall", width, 0.35, 0.6, 1.55, 0, -(m.d / 2) + 0.175);
+            store([["kitchen_cabinet_wall", wall.item]], overhead || []);
+            list2.push(wall);
+          }
+          if (m.outlet) sink.connections.outlet = m.outlet;
+        } else {
+          const basin = part(m.id, "sink_bathroom", m.w, m.d, m.h + 0.2, 0, 0, 0);
+          list2.push(basin);
+          if (contents[m.id]) {
+            if (contents[m.id].length) {
+              const cabinet = part(m.id + "#cabinet", "bathroom_cabinet", Math.max(0.45, Math.min(0.6, m.w)), 0.15, 0.75, 1.3, 0, -(m.d / 2) + 0.075);
+              list2.push(cabinet);
+              store([["bathroom_cabinet", cabinet.item], ["sink_bathroom", basin.item]], contents[m.id]);
+            } else {
+              store([["sink_bathroom", basin.item]], []);
+            }
+          }
+        }
+        for (const e of list2) push(e);
+      }
+      function circuitOfLight(id) {
+        const direct = circuits.find((c) => (c.lamps || []).indexOf(id) >= 0);
+        if (direct) return direct.id;
+        const sw = (electrical && electrical.switches || []).find((s) => (s.controls || []).indexOf(id) >= 0);
+        const viaSwitch = sw && circuits.find((c) => (c.switches || []).indexOf(sw.id) >= 0);
+        return viaSwitch ? viaSwitch.id : "standalone_circuit";
+      }
+      function planLamp(m, map) {
+        const item = baseItem(m);
+        delete item.palette;
+        const e = entry2(m.id, "lamp", item, m.id, m.floor, { watts: map.watts });
+        e.connections.circuit = circuitOfLight(m.id);
+        e.lit = initialLight(res, popts, m.id, e);
+        push(e);
+        result.lights.push(e.id);
+      }
+      for (const m of res.items || []) {
+        if (!onFloor(m.floor, m.outdoor)) continue;
+        const map = typeMap[m.type];
+        if (!map) {
+          const k = m.category + "/" + m.type;
+          result.unmapped[k] = (result.unmapped[k] || 0) + 1;
+          continue;
+        }
+        result.mapped.push(m.id);
+        if (map.type === "lamp") planLamp(m, map);
+        else if (map.compound) planCompound(m, map.compound);
+        else planSimple(m, map);
+      }
+      result.chairs = [];
+      if (opts.chairs !== false && popts.chairs !== false) {
+        const blocked = blockedOf(res, { originX: o.ox, originZ: o.oz, inw: o.inw });
+        const floorKind = (q) => !q.decor && !q.flat && (q.y || 0) < 0.9 && q.aabb;
+        const placed = [];
+        const free = (m, cu, cv, half) => {
+          const a = [cu - half + 0.03, cv - half + 0.03, cu + half - 0.03, cv + half - 0.03];
+          for (const [dx, dz] of [[-1, -1], [1, -1], [-1, 1], [1, 1], [0, 0]]) if (blocked(K.x(cu + dx * half * 0.9), K.z(cv + dz * half * 0.9), m.floor)) return false;
+          for (const q of res.items || []) {
+            if (q === m || !floorKind(q) || q.floor !== m.floor && !(q.outdoor && m.outdoor)) continue;
+            if (a[0] < q.aabb[2] && a[2] > q.aabb[0] && a[1] < q.aabb[3] && a[3] > q.aabb[1]) return false;
+          }
+          for (const c of placed) if (a[0] < c[2] && a[2] > c[0] && a[1] < c[3] && a[3] > c[1] && c[4] === m.floor) return false;
+          placed.push([a[0], a[1], a[2], a[3], m.floor]);
+          return true;
+        };
+        for (const m of res.items || []) {
+          const mode = chairTables[m.type];
+          if (!mode || !onFloor(m.floor, m.outdoor) || m.frontU == null) continue;
+          const f = [m.frontU, m.frontV];
+          const pp = [-m.frontV, m.frontU];
+          const seats = [];
+          if (mode === "dining") {
+            const n = Math.max(1, Math.min(3, Math.floor((m.w - 0.1) / 0.55)));
+            for (const side of [1, -1]) {
+              for (let i = 0; i < n; i++) seats.push([(i - (n - 1) / 2) * (m.w / n), side * (m.d / 2 + 0.17), [-side * f[0], -side * f[1]]]);
+            }
+            if (m.w >= 1.6) for (const side of [1, -1]) seats.push([side * (m.w / 2 + 0.17), 0, [-side * pp[0], -side * pp[1]]]);
+          } else {
+            seats.push([0, m.d / 2 + 0.2, [-f[0], -f[1]]]);
+          }
+          seats.forEach((lg, i) => {
+            const cu = r3(m.x + pp[0] * lg[0] + f[0] * lg[1]);
+            const cv = r3(m.z + pp[1] * lg[0] + f[1] * lg[1]);
+            const half = mode === "dining" ? chairSide / 2 : 0.3;
+            if (!free(m, cu, cv, half)) return;
+            const id = m.id + "#chair" + (i + 1);
+            const item = { x: K.x(cu), z: K.z(cv), ry: K.ry(lg[2][0], lg[2][1]), seed: seedOf2(id), palette };
+            if (mode !== "dining") {
+              item.w = 0.6;
+              item.d = 0.6;
+              item.h = 0.95;
+            }
+            const e = push(entry2(id, mode === "dining" ? "dining_chair" : "armchair", item, m.id, m.floor));
+            result.chairs.push(e.id);
+          });
+        }
+      }
+      function conduit(id, pts, floor) {
+        const x0 = K.x(pts[0][0]);
+        const z0 = K.z(pts[0][1]);
+        const item = {
+          x: x0,
+          z: z0,
+          ry: 0,
+          seed: seedOf2(id),
+          // the points of the plan already have the absolute y of the world: the object stays on the base ground and not on the floor of the storey
+          points: pts.map((p) => [r3(K.x(p[0]) - x0), p[2], r3(K.z(p[1]) - z0)])
+        };
+        const e = entry2(id, "conduit_run", item, id, floor);
+        e.floorY = o.base;
+        push(e);
+        result.conduits.push(e.id);
+      }
+      if (electrical) {
+        for (const l of electrical.outdoorLamps || []) {
+          if (!onFloor(-1, true)) continue;
+          const e = entry2(l.id, "lamp", { x: K.x(l.u), z: K.z(l.v), ry: 0, y: l.y, seed: seedOf2(l.id) }, l.id, -1, { watts: 15 });
+          e.connections.circuit = circuitOfLight(l.id);
+          e.lit = initialLight(res, popts, l.id, e);
+          push(e);
+          result.lights.push(e.id);
+        }
+        for (const t of electrical.outlets || []) {
+          if (!onFloor(t.floor, false)) continue;
+          const c = circuits.find((x) => (x.outlets || []).indexOf(t.id) >= 0);
+          const item = { x: K.x(t.u), z: K.z(t.v), ry: K.ry(t.frontU, t.frontV), y: t.y, seed: seedOf2(t.id) };
+          if (c) item.circuit = c.id;
+          const e = entry2(t.id, "wall_socket", item, t.id, t.floor);
+          e.connections.circuit = c ? c.id : null;
+          push(e);
+          result.outlets.push(e.id);
+        }
+        const lights = new Set(result.lights);
+        for (const s of electrical.switches || []) {
+          if (!onFloor(s.floor, false)) continue;
+          const item = { x: K.x(s.u), z: K.z(s.v), ry: K.ry(s.frontU, s.frontV), y: s.y, seed: seedOf2(s.id) };
+          item.controls = (s.controls || []).map((id) => id + ":lamp");
+          const e = entry2(s.id, "wall_switch", item, s.id, s.floor);
+          e.connections.controls = (s.controls || []).slice();
+          e.lit = e.connections.controls.some((id) => (result.items.find((x) => x.id === id) || {}).lit === true);
+          if (floorSel == null) {
+            for (const id of s.controls || []) if (!lights.has(id)) result.warnings.push(msg("warn.switchUnknownLamp", { id: s.id, lamp: id }));
+          }
+          push(e);
+          result.switches.push(e.id);
+        }
+        const ee = electrical.serviceEntrance;
+        if (ee && ee.pole && onFloor(-1, true)) {
+          const drop = ee.drop || [];
+          const end = drop.length ? drop[drop.length - 1] : [ee.pole.u, ee.pole.v, 2.6];
+          const px = K.x(ee.pole.u);
+          const pz = K.z(ee.pole.v);
+          const item = {
+            x: px,
+            z: pz,
+            ry: 0,
+            h: ee.pole.h,
+            seed: seedOf2("service_entrance"),
+            // point where the drop reaches the house, in local coordinates of the pole (absolute y)
+            house: [r3(K.x(end[0]) - px), end[2], r3(K.z(end[1]) - pz)]
+          };
+          if (ee.tap || electrical.mode === "tap") item.variant = "gato";
+          const e = entry2("service_entrance", "service_entrance", item, "service_entrance", -1);
+          push(e);
+          result.serviceEntrance = e.id;
+          if (ee.descent && ee.descent.length > 1) conduit("conduit_descent", ee.descent, -1);
+        }
+        const q = electrical.panel;
+        if (q && onFloor(q.floor, false)) {
+          const hdq = 0.06;
+          const ryq = K.ry(q.frontU, q.frontV);
+          const item = {
+            x: r3(K.x(q.u) + Math.sin(ryq) * hdq),
+            z: r3(K.z(q.v) + Math.cos(ryq) * hdq),
+            ry: ryq,
+            y: q.y,
+            seed: seedOf2("panel"),
+            circuits: circuits.map((c) => ({ id: c.id, label: c.room }))
+          };
+          if (!item.circuits.length) delete item.circuits;
+          const e = entry2("panel", "electrical_panel", item, "panel", q.floor);
+          push(e);
+          result.panel = e.id;
+        }
+        const med = ee && ee.meter;
+        if (med && onFloor(-1, true)) {
+          const hdm = 0.08;
+          const item = { x: K.x(med.u), z: r3(K.z(med.v) - o.inw * hdm), ry: K.ry(0, -1), y: med.y, seed: seedOf2("meter") };
+          const e = entry2("meter", "power_meter", item, "meter", -1);
+          push(e);
+          result.meter = e.id;
+        }
+        for (const ed of electrical.conduits || []) {
+          if (!ed.exposed || !ed.points || ed.points.length < 2) continue;
+          const circ = circuits.find((c) => c.id === ed.circuit);
+          const floor = circ ? circ.floor : 0;
+          if (!onFloor(floor, false)) continue;
+          conduit(ed.id, ed.points, floor);
+        }
+      }
+      const piped = result.items.filter((e) => e.type === "stove" && e.connections.gas === "piped");
+      if (piped.length) {
+        const med = utilities.gas && utilities.gas.meter;
+        const ref = med ? { x: K.x(med.u), z: K.z(med.v), y: med.y || 1 } : { x: piped[0].item.x, z: piped[0].item.z, y: 0.3 };
+        const e = entry2("piped_gas", "gas_piped", { x: ref.x, z: ref.z, ry: 0, y: ref.y, seed: seedOf2("piped_gas") }, "piped_gas", piped[0].floor);
+        e.floorY = o.base;
+        push(e);
+        for (const f of piped) f.connections.fuel = "piped_gas:gas";
+      }
+      for (const b of result.cylinders) {
+        const stove = result.items.find((e) => e.id === b.stove);
+        if (stove) stove.connections.fuel = b.id + ":gas";
+      }
+      const plumbing = utilities.plumbing;
+      if (plumbing) {
+        const isCabinet = (t) => t === "kitchen_cabinet_base" || t === "kitchen_cabinet_wall" || t === "bathroom_cabinet";
+        for (const p of plumbing.points || []) {
+          const target = (byOrigin.get(p.item) || []).filter((e) => !isCabinet(e.type))[0];
+          if (!target) {
+            if (floorSel == null) result.warnings.push(msg("warn.pointNoObject", { id: p.id, kind: p.kind, item: p.item }));
+            continue;
+          }
+          target.point = p.id;
+          target.connections.flowLpm = p.flowLpm;
+          for (const f of fixturesOfPoint[p.kind] || []) {
+            result.fixtures.push({ object: target.id, fixture: f, global: target.id + ":" + f, point: p.id, pointKind: p.kind });
+            result.points[target.id + ":" + f] = p.id;
+          }
+        }
+      }
+      hideCylinders();
+      return result;
+    }
+    function ownSpec(entry2) {
+      if (entry2.type === "lamp") {
+        const dev = { id: "lamp", kind: "lamp", watts: entry2.watts || 15, on: !!entry2.lit };
+        if (entry2.connections.circuit) dev.circuit = entry2.connections.circuit;
+        return { type: "lamp", devices: [dev] };
+      }
+      if (entry2.type === "gas_piped") return { type: "gas_piped", fuels: [{ id: "gas", kind: "gas", capacity: 1e3, level: 1e3 }] };
+      throw new Error(msg("error.unknownOwnType", { type: entry2.type }));
+    }
+    function connect(entry2, spec) {
+      const L = entry2.connections || {};
+      if (entry2.type === "wall_switch") {
+        for (const p of spec.parts || []) if (p.id === "rocker") p.t0 = entry2.lit ? 1 : 0;
+      }
+      if (entry2.type !== "shower") {
+        for (const dv of spec.devices || []) if (L.outlet && dv.socket === "auto") dv.socket = L.outlet + ":socket";
+      } else {
+        const sh = L.shower || {};
+        const heater = (spec.devices || []).find((d) => d.id === "heater");
+        if (heater && sh.electric === false) {
+          spec.devices = spec.devices.filter((d) => d !== heater);
+          for (const f of spec.fixtures || []) if (f.heater === "heater") delete f.heater;
+        } else if (heater) {
+          if (sh.powerW) heater.watts = sh.powerW;
+          if (L.outletCircuit) heater.circuit = L.outletCircuit;
+        }
+      }
+      if ((entry2.type === "stove" || entry2.type === "camp_stove") && L.fuel) {
+        for (const b of spec.burners || []) if (b.fuel === "auto") b.fuel = L.fuel;
+      }
+      if (entry2.type === "fireplace" && L.chimneyTop) {
+        const it = entry2.item;
+        const dx = L.chimneyTop[0] - it.x;
+        const dz = L.chimneyTop[2] - it.z;
+        const lx = Math.cos(it.ry) * dx - Math.sin(it.ry) * dz;
+        const lz = Math.sin(it.ry) * dx + Math.cos(it.ry) * dz;
+        for (const em of spec.emitters || []) if (em.kind === "smoke") em.pos = [r3(lx), r3(L.chimneyTop[1] - entry2.floorY + 0.02), r3(lz)];
+      }
+      if (entry2.type === "washing_machine" && entry2.point) {
+        spec.fixtures = spec.fixtures || [];
+        const inlet = spec.fixtures.find((f) => f.id === "inlet");
+        if (inlet) {
+          if (L.flowLpm) inlet.flow = L.flowLpm;
+          inlet.tank = "auto";
+        } else {
+          spec.fixtures.push({ id: "inlet", kind: "hose", outlet: [0, 0.3, -(entry2.item.d || 0.6) / 2], flow: L.flowLpm || 8, tank: "auto" });
+        }
+      }
+      return spec;
+    }
+    function createWorld(res, copts = {}) {
+      copts = copts || {};
+      const info = { points: /* @__PURE__ */ new Map(), water: copts.water || null, lightsOn: copts.lightsOn };
+      const electrical = res.utilities && res.utilities.electrical;
+      const world = GI.createWorld({
+        locale,
+        strings: hh.strings,
+        items: hh.items,
+        loot: hh.loot,
+        seed: copts.seed != null ? copts.seed : res.seed,
+        // no grid: the cabin and the off-grid campsite have no service entrance, sockets or electric lamps (lanterns do not need a grid)
+        grid: copts.grid != null ? !!copts.grid : !!electrical && electrical.mode !== "offgrid",
+        onEvent: copts.onEvent,
+        canInteract: copts.canInteract,
+        waterSupply: {
+          draw(fixtureId, l) {
+            if (!info.water) return l;
+            const point = info.points.get(fixtureId);
+            return point == null ? l : info.water.consume(point, l);
+          }
+        }
+      });
+      worlds.set(world, info);
+      return world;
+    }
+    function pointOf(world, fixtureId) {
+      const info = worlds.get(world);
+      return info ? info.points.get(fixtureId) : void 0;
+    }
+    function blockedOf(res, bopts = {}) {
+      bopts = bopts || {};
+      const ox = bopts.originX || 0;
+      const oz = bopts.originZ || 0;
+      const inw = bopts.inw || 1;
+      const margin = bopts.margin != null ? bopts.margin : 0.02;
+      const segs = (res.walls || []).map((p) => {
+        const e = Math.max(0, p.thickness / 2 - margin);
+        const u0 = Math.min(p.u0, p.u1) - (p.axis === "u" ? 0 : e);
+        const u1 = Math.max(p.u0, p.u1) + (p.axis === "u" ? 0 : e);
+        const v0 = Math.min(p.v0, p.v1) - (p.axis === "v" ? 0 : e);
+        const v1 = Math.max(p.v0, p.v1) + (p.axis === "v" ? 0 : e);
+        const za = oz + inw * v0;
+        const zb = oz + inw * v1;
+        return { floor: p.floor, x0: ox + u0, x1: ox + u1, z0: Math.min(za, zb), z1: Math.max(za, zb) };
+      });
+      const CELL2 = 0.5;
+      const grid = /* @__PURE__ */ new Map();
+      const key = (a, i, j) => (a * 4096 + (i + 2048)) * 4096 + (j + 2048);
+      for (const s of segs) {
+        for (let i = Math.floor(s.x0 / CELL2); i <= Math.floor(s.x1 / CELL2); i++) {
+          for (let j = Math.floor(s.z0 / CELL2); j <= Math.floor(s.z1 / CELL2); j++) {
+            const k = key(s.floor, i, j);
+            if (!grid.has(k)) grid.set(k, []);
+            grid.get(k).push(s);
+          }
+        }
+      }
+      return function blocked(x, z, floor) {
+        const a = floor == null || floor < 0 ? 0 : floor;
+        const list2 = grid.get(key(a, Math.floor(x / CELL2), Math.floor(z / CELL2)));
+        if (!list2) return false;
+        for (const s of list2) if (x > s.x0 && x < s.x1 && z > s.z0 && z < s.z1) return true;
+        return false;
+      };
+    }
+    function add(world, planned, aopts = {}) {
+      aopts = aopts || {};
+      const info = worlds.get(world);
+      const build = aopts.build || ((type, item) => hh.build(type, item, HH.createRecorder().api));
+      const isBlocked = aopts.isBlocked || null;
+      const out = { added: 0, parts: [], hinges: {}, moved: {}, warnings: [] };
+      const override = aopts.lightsOn !== void 0 ? aopts.lightsOn : info && info.lightsOn;
+      if (override !== void 0) {
+        for (const e of planned.items) if (e.type === "lamp") e.lit = typeof override === "function" ? !!override(e.id, e) : !!override;
+        for (const e of planned.items) if (e.type === "lantern_lamp") e.lit = typeof override === "function" ? !!override(e.id, e) : !!override;
+        for (const e of planned.items) if (e.type === "wall_switch") e.lit = (e.connections.controls || []).some((id) => (planned.items.find((x) => x.id === id) || {}).lit === true);
+      }
+      for (const e of planned.items) if (e.type === "lantern_lamp") e.item.on = !!e.lit;
+      let scratch = null;
+      function probe(e, hinge, setback) {
+        if (!scratch) scratch = GI.createWorld({ locale, strings: hh.strings, items: hh.items, loot: hh.loot, grid: false });
+        const it = e.item;
+        const x = it.x + Math.sin(it.ry) * setback;
+        const z = it.z + Math.cos(it.ry) * setback;
+        const spec = hh.build(e.type, Object.assign({}, it, { hinge }), HH.createRecorder().api);
+        scratch.add("__probe", spec, { x, y: e.floorY, z, ry: it.ry });
+        const blocks = (px, pz) => isBlocked(px, pz, e.floor);
+        let sum = 0;
+        let min = 1;
+        let n = 0;
+        for (const p of spec.parts || []) {
+          if (p.motion.kind !== "hinge" || !(p.bounds || p.sweep)) continue;
+          const t = scratch.fitSweep("__probe", p.id, blocks);
+          sum += t;
+          min = Math.min(min, t);
+          n++;
+        }
+        scratch.remove("__probe");
+        return { sum, min, n };
+      }
+      const better = (a, b) => a.sum > b.sum + 1e-9 || Math.abs(a.sum - b.sum) <= 1e-9 && a.min > b.min + 1e-9;
+      function fitDoors(e) {
+        if (!isBlocked || !householdTypes.has(e.type)) return;
+        const standard = probe(e, void 0, 0);
+        if (!standard.n || standard.min >= 1) return;
+        let bestSide;
+        let m = standard;
+        for (const side of ["left", "right"]) {
+          const r = probe(e, side, 0);
+          if (better(r, m)) {
+            m = r;
+            bestSide = side;
+          }
+        }
+        if (bestSide) {
+          e.item.hinge = bestSide;
+          out.hinges[e.id] = bestSide;
+        }
+        if (m.min >= 1) return;
+        let target = { setback: 0, r: m };
+        for (const setback of [0.01, 0.02, 0.03, 0.04]) {
+          const r = probe(e, bestSide, setback);
+          if (better(r, target.r)) target = { setback, r };
+          if (r.min >= 1) break;
+        }
+        if (target.setback > 0 && target.r.sum > m.sum + 0.2) {
+          e.item.x = r3(e.item.x + Math.sin(e.item.ry) * target.setback);
+          e.item.z = r3(e.item.z + Math.cos(e.item.ry) * target.setback);
+          e.moved = target.setback;
+          out.moved[e.id] = target.setback;
+        }
+      }
+      for (const e of planned.items) {
+        if (e.type !== "shower" || !e.connections.outlet) continue;
+        const t = planned.items.find((x) => x.id === e.connections.outlet);
+        if (t && t.connections.circuit) e.connections.outletCircuit = t.connections.circuit;
+      }
+      for (const e of planned.items) {
+        let spec;
+        if (ownTypes[e.type]) {
+          spec = ownSpec(e);
+        } else {
+          fitDoors(e);
+          spec = build(e.type, e.item);
+          if (!spec) {
+            out.warnings.push(msg("warn.buildEmpty", { id: e.id }));
+            continue;
+          }
+        }
+        connect(e, spec);
+        world.add(e.id, spec, { x: e.item.x, y: e.floorY, z: e.item.z, ry: e.item.ry });
+        out.added++;
+        if (!isBlocked) continue;
+        for (const p of spec.parts || []) {
+          if (!(p.bounds || p.sweep)) continue;
+          const t = world.fitSweep(e.id, p.id, (x, z) => isBlocked(x, z, e.floor));
+          if (t < 1) out.parts.push({ object: e.id, part: p.id, t });
+        }
+      }
+      if (info) for (const f of planned.fixtures) info.points.set(f.global, f.point);
+      return out;
+    }
+    return { version: ADAPTER_VERSION, household: hh, plan, createWorld, add, blockedOf, pointOf, ownSpec, registries: { typeMap, contentMap, contentByGroup, chairTables, fixturesOfPoint, substitutes, preference, ownTypes } };
+  }
+  var FloorplanInteractables = { version: ADAPTER_VERSION, create: create2, TYPE_MAP, CONTENT_MAP, CONTENT_BY_GROUP, CHAIR_TABLES, PREFERENCE, mergeRegistry };
+
   // src/interactables/kit.ts
   function installInteractablesKit(K, shared) {
     const { t, THREE, DOC, cfg, Reflector } = K;
@@ -7530,12 +9148,12 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     const IVK = (() => {
       const o = cfg.interactives;
       if (!o) return null;
-      const GI = o.GameInteractables || null, HH = o.GameInteractablesHousehold || null, GT = o.GameInteractablesThree || null, AD = o.adapter || null;
-      if (!GI || !HH || !GT || !AD) {
+      const GI = o.GameInteractables || null, HH = o.GameInteractablesHousehold || null, GT = o.GameInteractablesThree || null, AD = o.adapter || FloorplanInteractables;
+      if (!GI || !HH || !GT) {
         console.warn(t("warn.interactablesIncomplete"));
         return null;
       }
-      const A = AD.plan ? AD : AD.create({ GameInteractables: GI, GameInteractablesHousehold: HH, locale: o.locale, region: o.region });
+      const A = AD.plan ? AD : AD.create({ ...o.adapterOptions || {}, GameInteractables: GI, GameInteractablesHousehold: HH, locale: o.locale || cfg.locale, region: o.region, ...cfg.seedKey ? { seedKey: cfg.seedKey } : {} });
       return { GI, HH, GT, A, gfx: GT.createThreeAdapter(THREE, { document: DOC, Reflector }), items: o.items !== false, effects: o.effects !== false, camera: o.camera || null, onEvent: o.onEvent || null, onSeat: o.onSeat || null };
     })();
     const VEG = (() => {
@@ -7636,13 +9254,13 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
           }
           for (const g of by.values()) {
             const ls = g.ls, n = ls.length;
-            let cx = 0, cy = 0, cz = 0, range = 0;
+            let cx = 0, cy = 0, cz = 0, range2 = 0;
             for (const l of ls) {
               _p.set(l.x, l.y, l.z).applyMatrix4(M);
               cx += _p.x;
               cy += _p.y;
               cz += _p.z;
-              range = Math.max(range, l.range || 5);
+              range2 = Math.max(range2, l.range || 5);
             }
             cx /= n;
             cy /= n;
@@ -7650,7 +9268,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
             g.pos = [cx, cy, cz];
             g.color = ls[0].color;
             g.n = n;
-            g.range = range;
+            g.range = range2;
             if (g.exterior) {
               g.rects = [[cx - 7, cz - 7, cx + 7, cz + 7]];
               g.y = [cy - 3.2, cy + 4];
@@ -8923,8 +10541,8 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     const resting = /* @__PURE__ */ new Map();
     const carrying = /* @__PURE__ */ new Map();
     const push = (map, key, value) => {
-      const list = map.get(key);
-      if (list) list.push(value);
+      const list2 = map.get(key);
+      if (list2) list2.push(value);
       else map.set(key, [value]);
     };
     for (const support of supports) {
@@ -8980,7 +10598,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     if (!splits.size) return input;
     const boxes = new Map(input.parts.map((part) => [part.id, part.aabb]));
     const pieceBox = /* @__PURE__ */ new Map();
-    for (const split of splits.values()) for (const piece of split.pieces) pieceBox.set(piece.id, piece.aabb);
+    for (const split of splits.values()) for (const piece2 of split.pieces) pieceBox.set(piece2.id, piece2.aabb);
     const parts = input.parts.flatMap((part) => splits.get(part.id)?.pieces ?? [part]);
     const supports = [];
     for (const support of input.supports) {
@@ -9028,12 +10646,12 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       for (const [a, b] of cutAt(from, to, openings.filter((o) => o.wall === wall.id), y0, y1)) for (const [x0, x1] of unitsOf(a, b, row, spec)) cells.push({ from: x0, to: x1, row, y0, y1 });
     }
     const total = cells.reduce((sum, cell) => sum + (cell.to - cell.from) * (cell.y1 - cell.y0), 0);
-    const box = (cell) => alongU ? [cell.from, cross[0], cell.to, cross[1]] : [cross[0], cell.from, cross[1], cell.to];
+    const box2 = (cell) => alongU ? [cell.from, cross[0], cell.to, cross[1]] : [cross[0], cell.from, cross[1], cell.to];
     const pieces = cells.map((cell, index) => ({
       id: `${wall.id}_${spec.unitLength ? "u" : "log"}${cell.row}_${index}`,
       role: wall.role,
       material: wall.material,
-      aabb: box(cell),
+      aabb: box2(cell),
       y0: cell.y0,
       y1: cell.y1,
       floor: wall.floor,
@@ -9159,9 +10777,9 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       const capacity = input.capacities.get(id);
       capacities.delete(id);
       if (capacity === void 0) continue;
-      const along = (box) => Math.max(box[2] - box[0], box[3] - box[1]);
+      const along = (box2) => Math.max(box2[2] - box2[0], box2[3] - box2[1]);
       const length = along(input.parts.find((part) => part.id === id).aabb);
-      for (const piece of split.pieces) capacities.set(piece.id, Math.max(1, capacity * along(piece.aabb) / length));
+      for (const piece2 of split.pieces) capacities.set(piece2.id, Math.max(1, capacity * along(piece2.aabb) / length));
     }
     return { ...next, capacities };
   }
@@ -9438,7 +11056,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         const per = Math.max(1, Math.round(len / ul));
         const w = len / per;
         const edge = fragmentMaterial(part.material).color.getHex();
-        const list = [];
+        const list2 = [];
         for (let r = 0; r < rows; r++) {
           const shift = units.bond === "running" && r & 1 ? w / 2 : 0;
           const cells = per + (shift ? 1 : 0);
@@ -9453,10 +11071,10 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
             const y = part.y0 + (r + 0.5) * rowH;
             const d = Math.hypot(x - opening.center[0], y - opening.center[1], z - opening.center[2]);
             if (d < opening.radius) continue;
-            list.push({ x, y, z, sx: alongU ? b - a : thick, sy: rowH, sz: alongU ? thick : b - a, colour: d < opening.radius + 0.25 || paint === null ? edge : paint });
+            list2.push({ x, y, z, sx: alongU ? b - a : thick, sy: rowH, sz: alongU ? thick : b - a, colour: d < opening.radius + 0.25 || paint === null ? edge : paint });
           }
         }
-        return list;
+        return list2;
       }
       function open(event) {
         if (lod !== 0 || views.has(event.part) || !event.opening) return false;
@@ -9465,27 +11083,27 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         if (!part || !spec || !spec.units) return false;
         const items = structure.meshesOf(event.part).filter((it) => it.mesh);
         if (!items.length) return false;
-        const list = courses(part, spec.units, event.opening, wallColour(items));
-        const mesh = new THREE.InstancedMesh(unitGeometry, unitMaterial, Math.max(1, list.length));
+        const list2 = courses(part, spec.units, event.opening, wallColour(items));
+        const mesh = new THREE.InstancedMesh(unitGeometry, unitMaterial, Math.max(1, list2.length));
         mesh.name = "breach:" + event.part;
-        list.forEach((u, i) => {
+        list2.forEach((u, i) => {
           tmp.m.compose(tmp.p.set(u.x, u.y, u.z), tmp.q.identity(), tmp.s.set(u.sx, u.sy, u.sz));
           mesh.setMatrixAt(i, tmp.m);
           mesh.setColorAt(i, tmp.c.setHex(u.colour));
         });
-        mesh.count = list.length;
+        mesh.count = list2.length;
         mesh.instanceMatrix.needsUpdate = true;
         if (mesh.instanceColor) mesh.instanceColor.needsUpdate = true;
         mesh.castShadow = true;
         mesh.receiveShadow = true;
         house.add(mesh);
         const saved = items.map((it) => ({ it, v0: it.v0, data: collapseRange(it.mesh, it.v0, it.v1) }));
-        views.set(event.part, { mesh, saved, units: list.length, opening: event.opening });
+        views.set(event.part, { mesh, saved, units: list2.length, opening: event.opening });
         invalidate();
         invalidateShadow();
         return true;
       }
-      function plain(view, shown) {
+      function plain2(view, shown) {
         for (const s of view.saved) {
           if (shown) restoreRange(s.it.mesh, s.v0, s.data);
           else s.data = collapseRange(s.it.mesh, s.v0, s.it.v1);
@@ -9511,7 +11129,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
           if (was === 0 === (level === 0)) return;
           for (const v of views.values()) {
             v.mesh.visible = level === 0;
-            plain(v, level !== 0);
+            plain2(v, level !== 0);
           }
           invalidate();
           invalidateShadow();
@@ -9521,7 +11139,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
           for (const v of views.values()) {
             v.mesh.removeFromParent();
             v.mesh.dispose();
-            if (lod === 0) plain(v, true);
+            if (lod === 0) plain2(v, true);
           }
           views.clear();
         },
@@ -9628,7 +11246,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       };
       D.dropPiece = (id) => {
         if (hiddenPieces.has(id) || bodies.has(id)) return;
-        const list = [], rr = rngString(id);
+        const list2 = [], rr = rngString(id);
         for (const it of structure.meshesOf(id)) {
           if (it.obj) {
             hide(it);
@@ -9637,10 +11255,10 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
           const m = extract(it);
           hide(it);
           const hy = (m.geometry.boundingBox.max.y - m.geometry.boundingBox.min.y) / 2;
-          list.push({ mesh: m, vy: 0, hy, y0: m.position.y, rot: 0, w: [(rr() - 0.5) * 0.5, (rr() - 0.5) * 0.3, (rr() - 0.5) * 0.5], landing: false });
+          list2.push({ mesh: m, vy: 0, hy, y0: m.position.y, rot: 0, w: [(rr() - 0.5) * 0.5, (rr() - 0.5) * 0.3, (rr() - 0.5) * 0.5], landing: false });
         }
         hiddenPieces.add(id);
-        if (list.length) bodies.set(id, list);
+        if (list2.length) bodies.set(id, list2);
         invalidate();
         invalidateShadow();
       };
@@ -9812,8 +11430,8 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       D.animate = (dt) => {
         if (R) return;
         let moved = false;
-        for (const [id, list] of bodies) {
-          for (const b of list) {
+        for (const [id, list2] of bodies) {
+          for (const b of list2) {
             if (b.landing) continue;
             moved = true;
             b.vy -= 9.8 * dt;
@@ -9829,10 +11447,10 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
               b.landing = true;
             }
           }
-          if (!list.impacted && list.every((b) => b.landing)) {
-            list.impacted = true;
+          if (!list2.impacted && list2.every((b) => b.landing)) {
+            list2.impacted = true;
             const ps = D.active ? D.world.part(D.id, id) : null;
-            const b = list[0];
+            const b = list2[0];
             if (ps && ps.status !== "broken") {
               const h = Math.max(0.5, b.y0 - b.hy), c = worldPoint(b.mesh.parent, b.mesh.position);
               D.world.hitPart(D.id, id, { type: "blunt", point: [c.x, c.y, c.z], energy: ps.mass * 9.8 * h, radius: 0.5, source: "fall" });
@@ -10413,7 +12031,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
 
   // src/create.ts
   var VERSION = "1.0.0";
-  function create2(THREE, options = {}) {
+  function create3(THREE, options = {}) {
     const cfg = Object.assign({}, options || {});
     const DOC = cfg.document || (typeof document !== "undefined" ? document : null);
     const PROPS = cfg.props || dist_exports;
@@ -10763,20 +12381,20 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       const g = c.grids[floor];
       if (!g) return 0;
       let x0, z0, x1, z1;
-      const circle = "circle" in shape ? shape.circle : null;
-      if (circle) {
-        x0 = circle[0] - circle[2];
-        z0 = circle[1] - circle[2];
-        x1 = circle[0] + circle[2];
-        z1 = circle[1] + circle[2];
+      const circle2 = "circle" in shape ? shape.circle : null;
+      if (circle2) {
+        x0 = circle2[0] - circle2[2];
+        z0 = circle2[1] - circle2[2];
+        x1 = circle2[0] + circle2[2];
+        z1 = circle2[1] + circle2[2];
       } else [x0, z0, x1, z1] = shape.rect;
       const i0 = Math.max(0, Math.ceil((Math.min(x0, x1) - c.ox) / CELL - 0.5)), i1 = Math.min(c.nx - 1, Math.floor((Math.max(x0, x1) - c.ox) / CELL - 0.5));
       const j0 = Math.max(0, Math.ceil((Math.min(z0, z1) - c.oz) / CELL - 0.5)), j1 = Math.min(c.nz - 1, Math.floor((Math.max(z0, z1) - c.oz) / CELL - 0.5));
       let n = 0;
       for (let j = j0; j <= j1; j++) for (let i = i0; i <= i1; i++) {
-        if (circle) {
-          const dx = c.ox + (i + 0.5) * CELL - circle[0], dz = c.oz + (j + 0.5) * CELL - circle[1];
-          if (dx * dx + dz * dz > circle[2] * circle[2]) continue;
+        if (circle2) {
+          const dx = c.ox + (i + 0.5) * CELL - circle2[0], dz = c.oz + (j + 0.5) * CELL - circle2[1];
+          if (dx * dx + dz * dz > circle2[2] * circle2[2]) continue;
         }
         fn(g, j * c.nx + i);
         n++;
@@ -11013,11 +12631,11 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     };
     const role = (p) => p.structure && p.structure.role;
     const events = (room) => {
-      const list = [];
-      room.world.on("*", (e) => list.push(e));
-      return list;
+      const list2 = [];
+      room.world.on("*", (e) => list2.push(e));
+      return list2;
     };
-    const collapsed = (list) => list.filter((e) => e.type === "collapse").flatMap((e) => e.parts.map((p) => p.id || p));
+    const collapsed = (list2) => list2.filter((e) => e.type === "collapse").flatMap((e) => e.parts.map((p) => p.id || p));
     const whole = (room, oid, pid) => {
       const p = room.world.part(oid, pid);
       return !!p && p.status !== "broken" && !p.stripped;
@@ -11036,14 +12654,14 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         name: text.scenarios.house_one_pillar,
         run({ room, step, expect }) {
           const { oid, parts, centre } = spawn(room, "house_casa_portico");
-          const list = events(room);
+          const list2 = events(room);
           const columns = groundColumns(parts);
           const laj = slabs(parts);
           blunt(room, oid, columns[0].id, centre(columns[0].id), 3e6);
           step(20);
           expect(!whole(room, oid, columns[0].id), fill(T2.one_pillar_broke, { id: columns[0].id }));
           expect(laj.length > 0 && laj.every((id) => whole(room, oid, id)), T2.slabs_whole);
-          expect(!collapsed(list).some((id) => laj.includes(id)), T2.no_slab_fell);
+          expect(!collapsed(list2).some((id) => laj.includes(id)), T2.no_slab_fell);
         }
       },
       {
@@ -11051,17 +12669,17 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         name: text.scenarios.house_two_pillars,
         run({ room, step, expect }) {
           const { oid, parts, centre } = spawn(room, "house_casa_portico");
-          const list = events(room);
+          const list2 = events(room);
           const columns = groundColumns(parts);
           const laj = slabs(parts);
           blunt(room, oid, columns[0].id, centre(columns[0].id), 3e6);
           blunt(room, oid, columns[1].id, centre(columns[1].id), 3e6);
           step(90);
-          for (let next = 2; next < columns.length && !slabs(parts).some((id) => collapsed(list).includes(id)); next++) {
+          for (let next = 2; next < columns.length && !slabs(parts).some((id) => collapsed(list2).includes(id)); next++) {
             blunt(room, oid, columns[next].id, centre(columns[next].id), 3e6);
             step(90);
           }
-          const fell = collapsed(list);
+          const fell = collapsed(list2);
           expect(laj.some((id) => fell.includes(id)), fill(T2.two_slab_fell, { n: fell.length }));
           expect(parts.filter((p) => role(p) === "roof").some((p) => fell.includes(p.id)), T2.two_roof_fell);
         }
@@ -11071,13 +12689,13 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         name: text.scenarios.house_partition,
         run({ room, step, expect }) {
           const { oid, parts, centre } = spawn(room, "house_casa_inteira");
-          const list = events(room);
+          const list2 = events(room);
           const partition = parts.find((p) => role(p) === "partition");
           const laj = slabs(parts);
           blunt(room, oid, partition.id, centre(partition.id), 3e6);
           step(20);
           expect(!whole(room, oid, partition.id), fill(T2.partition_broke, { id: partition.id }));
-          expect(laj.every((id) => whole(room, oid, id)) && !collapsed(list).some((id) => laj.includes(id)), T2.slab_stayed);
+          expect(laj.every((id) => whole(room, oid, id)) && !collapsed(list2).some((id) => laj.includes(id)), T2.slab_stayed);
         }
       },
       {
@@ -11116,12 +12734,12 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         name: text.scenarios.house_gas_explodes,
         run({ room, step, expect }) {
           const { oid, parts, centre } = spawn(room, "house_casa_inteira");
-          const list = events(room);
+          const list2 = events(room);
           const bottle = parts.find((p) => p.explodes);
           room.world.hitPart(oid, bottle.id, { type: "fire", point: centre(bottle.id), temperature: 900, radius: 0.6, duration: 8 });
           step(12);
-          expect(list.filter((e) => e.type === "explode").length > 0, T2.gas_exploded);
-          const damage = list.filter((e) => e.type === "damage" && e.part !== bottle.id && e.damageType === "explosive");
+          expect(list2.filter((e) => e.type === "explode").length > 0, T2.gas_exploded);
+          const damage = list2.filter((e) => e.type === "damage" && e.part !== bottle.id && e.damageType === "explosive");
           expect(damage.length > 0, fill(T2.gas_damaged, { n: new Set(damage.map((e) => e.part)).size }));
         }
       }
@@ -11162,7 +12780,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     let made = byId.get(key);
     if (!made) {
       const plan = engine.generate(def.template, { seed: def.seed ?? 1, ...def.state ? { state: def.state } : {} });
-      const house = create2(THREE, { ...houseOptions, destruction: void 0, destructionRenderer: void 0, interactives: void 0, vegetation: void 0, fleet: null }).build(plan, { quality: "game", terrain: false, noPerimeter: true });
+      const house = create3(THREE, { ...houseOptions, destruction: void 0, destructionRenderer: void 0, interactives: void 0, vegetation: void 0, fleet: null }).build(plan, { quality: "game", terrain: false, noPerimeter: true });
       const spec = house.structure.spec({ wallDetail: "coarse", ...def.portico ? { portico: true } : {} });
       house.dispose();
       made = { spec, plan };
@@ -11258,7 +12876,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       const key = `${settings.quality}|${locale}`;
       if (!houseRenderer || houseRendererKey !== key) {
         houseRenderer?.dispose?.();
-        houseRenderer = create2(THREE, {
+        houseRenderer = create3(THREE, {
           locale,
           lod: { interior: 10, hide: 40 },
           ...options.house,
@@ -11588,7 +13206,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         for (const group of groups) {
           for (const id of group.templates) {
             const plan = engine.generate(id, { seed: 1 });
-            const house = create2(THREE ?? host?.THREE, { locale, ...options.house, destruction: void 0, destructionRenderer: void 0, interactives: void 0, vegetation: void 0, fleet: null }).build(plan, { quality: "game", terrain: false, noPerimeter: true });
+            const house = create3(THREE ?? host?.THREE, { locale, ...options.house, destruction: void 0, destructionRenderer: void 0, interactives: void 0, vegetation: void 0, fleet: null }).build(plan, { quality: "game", terrain: false, noPerimeter: true });
             const ok = house.structure.parts.length > 0 && house.floors.length >= 1 && house.colliders.length > 0;
             expect(ok, `${groupName(group)}: ${templateName(id)} (${house.structure.parts.length})`);
             house.dispose();