@adatechnology/game-floorplan-three 0.2.0 → 0.2.1

package/dist/index.global.js

@@ -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
@@ -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() {
@@ -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,8 +7255,8 @@ 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]));
+      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 });
@@ -6997,7 +7276,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         }
         return add0(id, spec, tr);
       };
-      const added = 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 = added.warnings;
       IV.added = added;
@@ -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);
@@ -7102,10 +7381,10 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     }
     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) {
@@ -8091,10 +8370,10 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       const f = (res.floors || []).find((x) => x.index === floor);
       return r3(o.base + (f ? f.y0 : 0));
     }
-    function colorOf(res, color) {
-      if (color == null) return void 0;
-      if (typeof color === "number") return color;
-      const v = res.colors && res.colors[color];
+    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) {
@@ -8237,8 +8516,8 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
           seed: seedOf2(m.id),
           palette
         };
-        const color = colorOf(res, m.color);
-        if (color != null) item.color = color;
+        const color2 = colorOf(res, m.color);
+        if (color2 != null) item.color = color2;
         return item;
       }
       function entry2(id, type, item, origin, floor, extra) {
@@ -8385,17 +8664,17 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
           item.seed = seedOf2(id);
           return entry2(id, type, item, m.id, m.floor);
         };
-        const list = [];
+        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);
-          list.push(basin);
+          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);
-            list.push(wall);
+            list2.push(wall);
           }
           if (contents[m.id]) store([["sink_kitchen", basin.item]], contents[m.id]);
           if (m.outlet) basin.connections.outlet = m.outlet;
@@ -8405,33 +8684,33 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
           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);
-          list.push(sink);
+          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);
-            list.push(cabinet);
+            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 || []);
-            list.push(wall);
+            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);
-          list.push(basin);
+          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);
-              list.push(cabinet);
+              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 list) push(e);
+        for (const e of list2) push(e);
       }
       function circuitOfLight(id) {
         const direct = circuits.find((c) => (c.lamps || []).indexOf(id) >= 0);
@@ -8755,9 +9034,9 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       }
       return function blocked(x, z, floor) {
         const a = floor == null || floor < 0 ? 0 : floor;
-        const list = grid.get(key(a, Math.floor(x / CELL2), Math.floor(z / CELL2)));
-        if (!list) return false;
-        for (const s of list) if (x > s.x0 && x < s.x1 && z > s.z0 && z < s.z1) return true;
+        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;
       };
     }
@@ -8975,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;
@@ -8989,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];
@@ -10262,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) {
@@ -10319,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) {
@@ -10367,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,
@@ -10498,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 };
   }
@@ -10777,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);
@@ -10792,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;
@@ -10804,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);
@@ -10850,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();
@@ -10860,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();
         },
@@ -10967,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);
@@ -10976,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();
       };
@@ -11151,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;
@@ -11168,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" });
@@ -12102,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++;
@@ -12352,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;
@@ -12375,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);
         }
       },
       {
@@ -12390,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);
         }
@@ -12410,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);
         }
       },
       {
@@ -12455,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 }));
         }
       }