npm - @adatechnology/game-floorplan-three - Versions diffs - 0.8.3 → 0.9.1 - Mend

@adatechnology/game-floorplan-three 0.8.3 → 0.9.1

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

Files changed (13) hide show

package/README.md +4 -0
package/dist/chunk-QUVGWVEC.js +8882 -0
package/dist/chunk-QUVGWVEC.js.map +1 -0
package/dist/index.d.ts +6 -349
package/dist/index.global.js +631 -231
package/dist/index.global.js.map +1 -1
package/dist/index.js +23 -8627
package/dist/index.js.map +1 -1
package/dist/testing-ikPy2Nxl.d.ts +379 -0
package/dist/testing.d.ts +3 -0
package/dist/testing.js +19 -0
package/dist/testing.js.map +1 -0
package/package.json +23 -17

package/dist/index.global.js CHANGED Viewed

@@ -70,7 +70,7 @@ var GameFloorplanThree = (() => {
     shade: () => shade
   });
-  // ../game-shapes/dist/chunk-R4RY23RH.js
+  // ../game-shapes/dist/chunk-M5N2SHNL.js
   function canonicalJson(value) {
     if (value === null) return "null";
     if (typeof value === "number") return Object.is(value, -0) ? "-0" : Number.isFinite(value) ? String(value) : JSON.stringify(String(value));
@@ -1227,13 +1227,13 @@ var GameFloorplanThree = (() => {
       uvArray.push(x);
       uvArray.push(y);
     };
-    const at = (index, axis) => verticesArray[index * 3 + axis];
+    const at2 = (index, axis) => verticesArray[index * 3 + axis];
     const f3 = (a, b, c) => {
       addVertex(a);
       addVertex(b);
       addVertex(c);
       const nextIndex = verticesArray.length / 3;
-      for (const index of [nextIndex - 3, nextIndex - 2, nextIndex - 1]) addUV(at(index, 0), at(index, 1));
+      for (const index of [nextIndex - 3, nextIndex - 2, nextIndex - 1]) addUV(at2(index, 0), at2(index, 1));
     };
     const f4 = (a, b, c, d) => {
       addVertex(a);
@@ -1247,8 +1247,8 @@ var GameFloorplanThree = (() => {
       const iB = nextIndex - 3;
       const iC = nextIndex - 2;
       const iD = nextIndex - 1;
-      const byX = Math.abs(at(iA, 1) - at(iB, 1)) < Math.abs(at(iA, 0) - at(iB, 0));
-      const uv = (index) => [byX ? at(index, 0) : at(index, 1), 1 - at(index, 2)];
+      const byX = Math.abs(at2(iA, 1) - at2(iB, 1)) < Math.abs(at2(iA, 0) - at2(iB, 0));
+      const uv = (index) => [byX ? at2(index, 0) : at2(index, 1), 1 - at2(index, 2)];
       const uvs = [uv(iA), uv(iB), uv(iC), uv(iD)];
       for (const k of [0, 1, 3, 1, 2, 3]) addUV(...uvs[k]);
     };
@@ -1353,8 +1353,8 @@ var GameFloorplanThree = (() => {
       groups: []
     };
   }
-  function make(kind, p) {
-    switch (kind) {
+  function make(p) {
+    switch (p.kind) {
       case "box": {
         const size = p.size ?? [1, 1, 1];
         const segments = p.segments ?? [1, 1, 1];
@@ -1383,7 +1383,7 @@ var GameFloorplanThree = (() => {
       case "mesh":
         return mesh(p);
       default:
-        throw new Error(`game-shapes: unknown primitive kind "${String(kind)}"`);
+        throw new Error(`game-shapes: unknown primitive kind "${String(p.kind)}"`);
     }
   }
   var templates = /* @__PURE__ */ new Map();
@@ -1391,7 +1391,7 @@ var GameFloorplanThree = (() => {
   var stats = { hits: 0, misses: 0 };
   function buildPrimitive(node, options = {}) {
     const parameters = primitiveParameters(node, options);
-    if (node.kind === "mesh" || templateLimit === 0) return make(node.kind, parameters);
+    if (node.kind === "mesh" || templateLimit === 0) return make({ ...node, ...parameters });
     const key = `${node.kind}:${canonicalJson(parameters)}`;
     const cached = templates.get(key);
     if (cached) {
@@ -1401,7 +1401,7 @@ var GameFloorplanThree = (() => {
       return cached;
     }
     stats.misses++;
-    const built = make(node.kind, parameters);
+    const built = make({ ...node, ...parameters });
     templates.set(key, built);
     if (templates.size > templateLimit) templates.delete(templates.keys().next().value);
     return built;
@@ -1499,7 +1499,7 @@ var GameFloorplanThree = (() => {
     const positions2 = new Float32Array(total * 3);
     const normals = new Float32Array(total * 3);
     const uvs = new Float32Array(total * 2);
-    let at = 0;
+    let at2 = 0;
     for (const piece2 of pieces) {
       const e = piece2.matrix;
       const nm = normalMatrix(e);
@@ -1513,15 +1513,15 @@ var GameFloorplanThree = (() => {
           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];
+          uvs[(at2 + k) * 2] = piece2.uvs[i * 2];
+          uvs[(at2 + 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]);
-        positions2[(at + k) * 3] = q[0];
-        positions2[(at + k) * 3 + 1] = q[1];
-        positions2[(at + k) * 3 + 2] = q[2];
+        positions2[(at2 + k) * 3] = q[0];
+        positions2[(at2 + k) * 3 + 1] = q[1];
+        positions2[(at2 + k) * 3 + 2] = q[2];
         const x = n[k * 3];
         const y = n[k * 3 + 1];
         const z = n[k * 3 + 2];
@@ -1529,15 +1529,116 @@ var GameFloorplanThree = (() => {
         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;
+        normals[(at2 + k) * 3] = vx * s;
+        normals[(at2 + k) * 3 + 1] = vy * s;
+        normals[(at2 + k) * 3 + 2] = vz * s;
       }
-      at += count;
+      at2 += count;
     }
     return { positions: positions2, normals, uvs };
   }
+  // ../game-contracts/dist/index.js
+  var DEFAULT_COST_ALLOCATION_BYTES = 1024 * 1024;
+  var DEFAULT_IGNITION_RULES = {
+    fillCurve: [
+      [0, 0.6],
+      [0.1, 1],
+      [0.35, 0.6],
+      [0.65, 0.3],
+      [0.9, 0.15],
+      [1, 0.12]
+    ],
+    flameFillInfluence: 0.5,
+    flameDefaults: { incendiary: 0.7, tracer: 0.2 },
+    sparkTarget: { steel: 1, iron: 1, aluminium: 0.25 },
+    sparkMetalDefault: 0.5,
+    sparkFluid: { diesel: 0.15 },
+    fireNear: { radius: 1.5, chancePerSecond: 0.5 }
+  };
+  var resolveIgnitionRules = (rules) => ({
+    ...DEFAULT_IGNITION_RULES,
+    ...rules,
+    flameDefaults: { ...DEFAULT_IGNITION_RULES.flameDefaults, ...rules?.flameDefaults },
+    sparkTarget: { ...DEFAULT_IGNITION_RULES.sparkTarget, ...rules?.sparkTarget },
+    sparkFluid: { ...DEFAULT_IGNITION_RULES.sparkFluid, ...rules?.sparkFluid },
+    fireNear: { ...DEFAULT_IGNITION_RULES.fireNear, ...rules?.fireNear }
+  });
+  var fillFactor = (fill2, curve = DEFAULT_IGNITION_RULES.fillCurve) => {
+    if (curve.length === 0) return 1;
+    const f = Math.min(1, Math.max(0, fill2));
+    if (f <= curve[0][0]) return curve[0][1];
+    for (let i = 1; i < curve.length; i++) {
+      const [x1, y1] = curve[i];
+      const [x0, y0] = curve[i - 1];
+      if (f <= x1) return x1 === x0 ? y1 : y0 + (y1 - y0) * (f - x0) / (x1 - x0);
+    }
+    return curve[curve.length - 1][1];
+  };
+  var sparkTargetFactor = (materialId, metal, rules = DEFAULT_IGNITION_RULES) => !metal ? 0 : rules.sparkTarget[materialId] ?? rules.sparkMetalDefault;
+  var ignitionChance = (hit, target, rules = DEFAULT_IGNITION_RULES) => {
+    const k = fillFactor(target.fill, rules.fillCurve);
+    const spark = (hit.ignition?.spark ?? 0) * target.sparkTarget * (target.fluid === void 0 ? 1 : rules.sparkFluid[target.fluid] ?? 1) * k;
+    const flameBase = hit.ignition?.flame ?? Math.max(hit.incendiary ? rules.flameDefaults.incendiary : 0, hit.tracer ? rules.flameDefaults.tracer : 0);
+    const flame = flameBase * (1 - rules.flameFillInfluence * (1 - k));
+    return 1 - (1 - Math.min(1, Math.max(0, spark))) * (1 - Math.min(1, Math.max(0, flame)));
+  };
+  var DEFERRED_QUEUE_ID = {
+    DESTRUCTION_EVENTS: "destruction.events",
+    BREACH_PAINT: "floorplan.breach-paint",
+    AUDIO_VOICES: "audio.voices",
+    VEHICLE_CREASE: "vehicles.crease"
+  };
+  var DEFERRED_PRIORITY = {
+    [DEFERRED_QUEUE_ID.DESTRUCTION_EVENTS]: { priority: 300, phase: "present" },
+    [DEFERRED_QUEUE_ID.BREACH_PAINT]: { priority: 250, phase: "present" },
+    [DEFERRED_QUEUE_ID.AUDIO_VOICES]: { priority: 200, phase: "idle", reserveMs: 1 },
+    [DEFERRED_QUEUE_ID.VEHICLE_CREASE]: { priority: 100, phase: "idle" }
+  };
+  var KIT_ORIGIN_KEY = "kitOrigin";
+  function markKitOrigin(object2, origin) {
+    const node = object2;
+    node.userData = node.userData ?? {};
+    node.userData[KIT_ORIGIN_KEY] = { ...origin };
+    return object2;
+  }
+  var SURFACE_IDS = ["concrete", "asphalt", "wood", "tile", "dirt", "grass", "gravel", "sand", "metal", "water", "glass", "carpet"];
+  var GAIT_IDS = ["walk", "run"];
+  var LANDING_IDS = ["light", "heavy"];
+  var BODY_SOUND_IDS = [
+    "jump",
+    "cloth_rustle",
+    "body_fall",
+    "fall_damage",
+    "player_hurt",
+    "player_breath_run",
+    "player_death",
+    "bite",
+    "grab",
+    "punch_swing",
+    "punch_hit_body",
+    "punch_hit_face",
+    "punch_hit_object",
+    "kick_swing",
+    "kick_hit",
+    "kick_hit_object",
+    "shove_two_hands",
+    "knife_swing",
+    "knife_stab",
+    "knife_slash",
+    "knife_hit_object",
+    "blunt_swing",
+    "blunt_hit",
+    "blunt_hit_object",
+    "axe_swing",
+    "axe_chop",
+    "axe_hit_object"
+  ];
+  var footstepSoundId = (surface, gait) => `footstep_${surface}_${gait}`;
+  var FOOTSTEP_SOUND_IDS = SURFACE_IDS.flatMap((surface) => GAIT_IDS.map((gait) => footstepSoundId(surface, gait)));
+  var LAND_SOUND_IDS = SURFACE_IDS.flatMap((surface) => LANDING_IDS.map((landing) => `land_${surface}_${landing}`));
+  var BODY_FOLEY_IDS = [...FOOTSTEP_SOUND_IDS, ...LAND_SOUND_IDS, ...BODY_SOUND_IDS];
   // ../game-shapes-three/dist/index.js
   var UV_BEFORE_NORMAL = /* @__PURE__ */ new Set(["LatheGeometry", "ExtrudeGeometry"]);
   var INDEX_FIRST = /* @__PURE__ */ new Set(["BoxGeometry", "CylinderGeometry", "ConeGeometry", "SphereGeometry", "PlaneGeometry", "CircleGeometry", "RingGeometry", "LatheGeometry", "TorusGeometry"]);
@@ -3307,17 +3408,17 @@ var GameFloorplanThree = (() => {
       const index = geometry2.index ? geometry2.index.array : null;
       const count = index ? index.length : position.count;
       for (let item = 0; item < count; item++) {
-        const at = index ? index[item] : item;
-        vertex.fromBufferAttribute(position, at).applyMatrix4(matrix);
+        const at2 = index ? index[item] : item;
+        vertex.fromBufferAttribute(position, at2).applyMatrix4(matrix);
         positions2.push(vertex.x, vertex.y, vertex.z);
-        if (normalAttribute) normal.fromBufferAttribute(normalAttribute, at).applyMatrix3(normalMatrix2).normalize();
+        if (normalAttribute) normal.fromBufferAttribute(normalAttribute, at2).applyMatrix3(normalMatrix2).normalize();
         else normal.set(0, 1, 0);
         normals.push(normal.x, normal.y, normal.z);
         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;
-          const v = (uv.getY(at) * repeat.y % 1 + 1) % 1;
+          const u = (uv.getX(at2) * repeat.x % 1 + 1) % 1;
+          const v = (uv.getY(at2) * repeat.y % 1 + 1) % 1;
           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;
@@ -8997,7 +9098,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       const em = w.emitters();
       if (em.length && !IV.efx && K.IVK.effects) {
         const g = h.houseGroup;
-        IV.efx = ik.gfx.createEffects(g, { maxParticles: 1400, seed: 11, document: DOC });
+        IV.efx = ik.gfx.createEffects(g, { maxParticles: 1400, seed: 11, document: DOC, ...K.IVK.effectSink ? { effects: K.IVK.effectSink } : {} });
       }
       if (IV.efx) {
         const alive = IV.efx.stats().alive;
@@ -9770,8 +9871,10 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     // was `maquina`
   });
   var OWN_TYPES = Object.freeze({ lamp: true, gas_piped: true });
+  var sourceOf = (result) => result;
   var ADAPTER_VERSION = "0.3.0";
   var r3 = (n) => Math.round(n * 1e3) / 1e3;
+  var at = (it) => ({ x: it.x ?? 0, z: it.z ?? 0, ry: it.ry ?? 0 });
   function mergeRegistry(base, extra) {
     const out = { ...base };
     if (extra) {
@@ -9790,14 +9893,15 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
   });
   function create2(options = {}) {
     const opts = options || {};
-    const GI = opts.GameInteractables;
-    const HH = opts.GameInteractablesHousehold;
     const locale = opts.locale || "pt-BR";
     const msg = createTranslator2(locale, opts.messages);
-    if (!GI || !HH) throw new Error(msg("error.missingKit"));
+    if (!opts.GameInteractables || !opts.GameInteractablesHousehold) throw new Error(msg("error.missingKit"));
+    const GI = opts.GameInteractables;
+    const HH = opts.GameInteractablesHousehold;
     const region = opts.region || "br";
     const hh = HH.createHousehold({ locale, region });
     const householdTypes = new Set(hh.types.map((t) => t.id));
+    const recorderApi = () => HH.createRecorder().api;
     const worlds = /* @__PURE__ */ new WeakMap();
     const typeMap = mergeRegistry(TYPE_MAP, opts.typeMap);
     const contentMap = mergeRegistry(CONTENT_MAP, opts.contentMap);
@@ -9833,7 +9937,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     function colorOf(res, color2) {
       if (color2 == null) return void 0;
       if (typeof color2 === "number") return color2;
-      const v = res.colors && res.colors[color2];
+      const v = res.colors && res.colors[String(color2)];
       return typeof v === "number" ? v : void 0;
     }
     function paletteOf(res) {
@@ -9862,17 +9966,18 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       drawerItem: (s) => drawerItems.has(s.itemId)
     };
     const itemOfContent = (c) => {
-      const id = contentMap[c.itemId] || (hh.items[c.itemId] ? c.itemId : null) || contentByGroup[stackGroup(c)] || contentFallback;
+      const group = stackGroup(c);
+      const id = contentMap[c.itemId] || (hh.items[c.itemId] ? c.itemId : null) || (group != null ? contentByGroup[group] : void 0) || contentFallback;
       return hh.items[id] ? id : contentFallback;
     };
     const volume = (d) => d.size[0] * d.size[1] * d.size[2];
     const candidates = (id, objectType) => {
       const def = hh.items[id];
-      const siblings = Object.values(hh.items).filter((i) => i.category === def.category && i.id !== id).sort((a, b) => volume(a) - volume(b) || (a.id < b.id ? -1 : 1));
+      const siblings = Object.values(hh.items).filter((i) => i.category === def?.category && i.id !== id).sort((a, b) => volume(a) - volume(b) || (a.id < b.id ? -1 : 1));
       return [id].concat(siblings.map((i) => i.id), substitutes[objectType] || []);
     };
     function distribute(type, probeItem, stacks) {
-      const spec = hh.build(type, probeItem, HH.createRecorder().api);
+      const spec = hh.build(type, probeItem, recorderApi());
       const conts = spec.containers || [];
       const contents = {};
       for (const c of conts) contents[c.id] = c.slots.map(() => null);
@@ -9903,8 +10008,9 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       }
       return { contents, rejected };
     }
-    function plan(res, popts = {}) {
-      popts = popts || {};
+    function plan(source, options2 = {}) {
+      const res = sourceOf(source);
+      const popts = options2 || {};
       const o = { ox: popts.originX || 0, oz: popts.originZ || 0, inw: popts.inw || 1, base: popts.base || 0 };
       const K = conv(o);
       const floorSel = popts.floor;
@@ -9968,7 +10074,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         const item = {
           x: K.x(m.x),
           z: K.z(m.z),
-          ry: m.frontU != null ? K.ry(m.frontU, m.frontV) : r3(m.ry || 0),
+          ry: m.frontU != null ? K.ry(m.frontU, m.frontV ?? 0) : r3(m.ry || 0),
           w: m.w,
           d: m.d,
           h: m.h,
@@ -9981,7 +10087,8 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         return item;
       }
       function entry2(id, type, item, origin, floor, extra) {
-        return Object.assign({ id, type, item, origin, floor, floorY: floorYOf(res, o, floor), connections: {} }, extra || {});
+        const e = { id, type, item, origin, floor, floorY: floorYOf(res, o, floor), connections: {} };
+        return Object.assign(e, extra || {});
       }
       function store(targets, stacks) {
         let rest2 = stacks || [];
@@ -9994,10 +10101,11 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       }
       const hidden = [];
       function distRect(c, x, z) {
-        const dx = x - c.item.x;
-        const dz = z - c.item.z;
-        const s = Math.sin(c.item.ry);
-        const co = Math.cos(c.item.ry);
+        const ci = at(c.item);
+        const dx = x - ci.x;
+        const dz = z - ci.z;
+        const s = Math.sin(ci.ry);
+        const co = Math.cos(ci.ry);
         const lx = dx * co - dz * s;
         const lz = dx * s + dz * co;
         return Math.hypot(Math.max(Math.abs(lx) - (c.item.w || 0) / 2, 0), Math.max(Math.abs(lz) - (c.item.d || 0) / 2, 0));
@@ -10005,9 +10113,10 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       function hideCylinders() {
         for (const b of hidden) {
           let target = null;
+          const bi = at(b.item);
           for (const c2 of result.items) {
             if (c2.type !== "kitchen_cabinet_base" || c2.floor !== b.floor) continue;
-            const dist = distRect(c2, b.item.x, b.item.z);
+            const dist = distRect(c2, bi.x, bi.z);
             if (!target || dist < target.dist) target = { c: c2, dist };
           }
           if (!target) {
@@ -10015,16 +10124,18 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
             continue;
           }
           const c = target.c;
-          const spec = hh.build(c.type, c.item, HH.createRecorder().api);
-          const sn = Math.sin(c.item.ry);
-          const cs = Math.cos(c.item.ry);
+          const spec = hh.build(c.type, c.item, recorderApi());
+          const ci = at(c.item);
+          const sn = Math.sin(ci.ry);
+          const cs = Math.cos(ci.ry);
           let door = null;
           for (const it of spec.interactions || []) {
-            const pt = it.action && it.action.do === "toggle_part" ? (spec.parts || []).find((q) => q.id === it.action.part) : null;
-            if (!pt || pt.motion.kind !== "hinge") continue;
-            const wx = c.item.x + it.pos[0] * cs + it.pos[2] * sn;
-            const wz = c.item.z - it.pos[0] * sn + it.pos[2] * cs;
-            const dist = Math.hypot(wx - b.item.x, wz - b.item.z);
+            const action = it.action;
+            const pt = action.do === "toggle_part" ? (spec.parts || []).find((q) => q.id === action.part) : null;
+            if (!pt || !pt.motion || pt.motion.kind !== "hinge") continue;
+            const wx = ci.x + it.pos[0] * cs + it.pos[2] * sn;
+            const wz = ci.z - it.pos[0] * sn + it.pos[2] * cs;
+            const dist = Math.hypot(wx - bi.x, wz - bi.z);
             if (!door || dist < door.dist) door = { id: pt.id, dist };
           }
           if (!door) {
@@ -10054,9 +10165,10 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       const campCylinder = firstOfType("gas_canister");
       function planFireplace(m, e, item) {
         const def = hh.types.find((t) => t.id === "fireplace");
-        const lack = (def.d - m.d) / 2;
-        item.x = r3(item.x + Math.sin(item.ry) * lack);
-        item.z = r3(item.z + Math.cos(item.ry) * lack);
+        const lack = ((def ? def.d : m.d) - m.d) / 2;
+        const p = at(item);
+        item.x = r3(p.x + Math.sin(p.ry) * lack);
+        item.z = r3(p.z + Math.cos(p.ry) * lack);
         const room = (res.rooms || []).find((c) => c.id === m.room && c.floor === m.floor);
         const f = (res.floors || []).find((x) => x.index === m.floor);
         item.h = r3(room && room.ceiling || f && f.ceiling || 2.6);
@@ -10084,7 +10196,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
           e.connections.gas = m.gas || "cylinder";
           e.connections.cylinder = m.cylinder || null;
         }
-        if (map.type === "gas_bottle") result.cylinders.push({ id: e.id, stove: m.link || null, place: m.placement || null });
+        if (map.type === "gas_bottle") result.cylinders.push({ id: e.id, stove: typeof m.link === "string" ? m.link : null, place: m.placement || null });
         if (map.type === "gas_canister") {
           result.canisters.push(e.id);
           if (campCylinder && campCylinder.id === m.id && campStove) result.cylinders.push({ id: e.id, stove: campStove.id, place: null });
@@ -10108,7 +10220,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         push(e);
       }
       function planCompound(m, kind) {
-        const ry = m.frontU != null ? K.ry(m.frontU, m.frontV) : r3(m.ry || 0);
+        const ry = m.frontU != null ? K.ry(m.frontU, m.frontV ?? 0) : r3(m.ry || 0);
         const cx = K.x(m.x);
         const cz = K.z(m.z);
         const part = (id, type, w, d, h, y, lx, lz) => {
@@ -10160,11 +10272,12 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         } else {
           const basin = part(m.id, "sink_bathroom", m.w, m.d, m.h + 0.2, 0, 0, 0);
           list2.push(basin);
-          if (contents[m.id]) {
-            if (contents[m.id].length) {
+          const own = contents[m.id];
+          if (own) {
+            if (own.length) {
               const cabinet = part(m.id + "#cabinet", "bathroom_cabinet", Math.max(0.45, Math.min(0.6, m.w)), 0.15, 0.75, 1.3, 0, -(m.d / 2) + 0.075);
               list2.push(cabinet);
-              store([["bathroom_cabinet", cabinet.item], ["sink_bathroom", basin.item]], contents[m.id]);
+              store([["bathroom_cabinet", cabinet.item], ["sink_bathroom", basin.item]], own);
             } else {
               store([["sink_bathroom", basin.item]], []);
             }
@@ -10204,7 +10317,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       result.chairs = [];
       if (opts.chairs !== false && popts.chairs !== false) {
         const blocked = blockedOf(res, { originX: o.ox, originZ: o.oz, inw: o.inw });
-        const floorKind = (q) => !q.decor && !q.flat && (q.y || 0) < 0.9 && q.aabb;
+        const floorKind = (q) => !q.decor && !q.flat && (q.y || 0) < 0.9 && !!q.aabb;
         const placed = [];
         const free = (m, cu, cv, half) => {
           const a = [cu - half + 0.03, cv - half + 0.03, cu + half - 0.03, cv + half - 0.03];
@@ -10220,8 +10333,9 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         for (const m of res.items || []) {
           const mode = chairTables[m.type];
           if (!mode || !onFloor(m.floor, m.outdoor) || m.frontU == null) continue;
-          const f = [m.frontU, m.frontV];
-          const pp = [-m.frontV, m.frontU];
+          const fv = m.frontV ?? 0;
+          const f = [m.frontU, fv];
+          const pp = [-fv, m.frontU];
           const seats = [];
           if (mode === "dining") {
             const n = Math.max(1, Math.min(3, Math.floor((m.w - 0.1) / 0.55)));
@@ -10290,8 +10404,9 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
           const item = { x: K.x(s.u), z: K.z(s.v), ry: K.ry(s.frontU, s.frontV), y: s.y, seed: seedOf2(s.id) };
           item.controls = (s.controls || []).map((id) => id + ":lamp");
           const e = entry2(s.id, "wall_switch", item, s.id, s.floor);
-          e.connections.controls = (s.controls || []).slice();
-          e.lit = e.connections.controls.some((id) => (result.items.find((x) => x.id === id) || {}).lit === true);
+          const controls = (s.controls || []).slice();
+          e.connections.controls = controls;
+          e.lit = controls.some((id) => result.items.find((x) => x.id === id)?.lit === true);
           if (floorSel == null) {
             for (const id of s.controls || []) if (!lights.has(id)) result.warnings.push(msg("warn.switchUnknownLamp", { id: s.id, lamp: id }));
           }
@@ -10331,7 +10446,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
             seed: seedOf2("panel"),
             circuits: circuits.map((c) => ({ id: c.id, label: c.room }))
           };
-          if (!item.circuits.length) delete item.circuits;
+          if (!item.circuits?.length) delete item.circuits;
           const e = entry2("panel", "electrical_panel", item, "panel", q.floor);
           push(e);
           result.panel = e.id;
@@ -10353,10 +10468,11 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         }
       }
       const piped = result.items.filter((e) => e.type === "stove" && e.connections.gas === "piped");
-      if (piped.length) {
+      const firstPiped = piped[0];
+      if (firstPiped) {
         const med = utilities.gas && utilities.gas.meter;
-        const ref = med ? { x: K.x(med.u), z: K.z(med.v), y: med.y || 1 } : { x: piped[0].item.x, z: piped[0].item.z, y: 0.3 };
-        const e = entry2("piped_gas", "gas_piped", { x: ref.x, z: ref.z, ry: 0, y: ref.y, seed: seedOf2("piped_gas") }, "piped_gas", piped[0].floor);
+        const ref = med ? { x: K.x(med.u), z: K.z(med.v), y: med.y || 1 } : { x: firstPiped.item.x, z: firstPiped.item.z, y: 0.3 };
+        const e = entry2("piped_gas", "gas_piped", { x: ref.x, z: ref.z, ry: 0, y: ref.y, seed: seedOf2("piped_gas") }, "piped_gas", firstPiped.floor);
         e.floorY = o.base;
         push(e);
         for (const f of piped) f.connections.fuel = "piped_gas:gas";
@@ -10403,9 +10519,10 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         for (const dv of spec.devices || []) if (L.outlet && dv.socket === "auto") dv.socket = L.outlet + ":socket";
       } else {
         const sh = L.shower || {};
-        const heater = (spec.devices || []).find((d) => d.id === "heater");
+        const devices = spec.devices || [];
+        const heater = devices.find((d) => d.id === "heater");
         if (heater && sh.electric === false) {
-          spec.devices = spec.devices.filter((d) => d !== heater);
+          spec.devices = devices.filter((d) => d !== heater);
           for (const f of spec.fixtures || []) if (f.heater === "heater") delete f.heater;
         } else if (heater) {
           if (sh.powerW) heater.watts = sh.powerW;
@@ -10416,7 +10533,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         for (const b of spec.burners || []) if (b.fuel === "auto") b.fuel = L.fuel;
       }
       if (entry2.type === "fireplace" && L.chimneyTop) {
-        const it = entry2.item;
+        const it = at(entry2.item);
         const dx = L.chimneyTop[0] - it.x;
         const dz = L.chimneyTop[2] - it.z;
         const lx = Math.cos(it.ry) * dx - Math.sin(it.ry) * dz;
@@ -10435,8 +10552,9 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       }
       return spec;
     }
-    function createWorld(res, copts = {}) {
-      copts = copts || {};
+    function createWorld(source, options2 = {}) {
+      const res = sourceOf(source);
+      const copts = options2 || {};
       const info = { points: /* @__PURE__ */ new Map(), water: copts.water || null, lightsOn: copts.lightsOn };
       const electrical = res.utilities && res.utilities.electrical;
       const world = GI.createWorld({
@@ -10464,8 +10582,9 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       const info = worlds.get(world);
       return info ? info.points.get(fixtureId) : void 0;
     }
-    function blockedOf(res, bopts = {}) {
-      bopts = bopts || {};
+    function blockedOf(source, options2 = {}) {
+      const res = sourceOf(source);
+      const bopts = options2 || {};
       const ox = bopts.originX || 0;
       const oz = bopts.originZ || 0;
       const inw = bopts.inw || 1;
@@ -10500,33 +10619,33 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         return false;
       };
     }
-    function add(world, planned, aopts = {}) {
-      aopts = aopts || {};
+    function add(world, planned, options2 = {}) {
+      const aopts = options2 || {};
       const info = worlds.get(world);
-      const build = aopts.build || ((type, item) => hh.build(type, item, HH.createRecorder().api));
+      const build = aopts.build || ((type, item) => hh.build(type, item, recorderApi()));
       const isBlocked = aopts.isBlocked || null;
       const out = { added: 0, parts: [], hinges: {}, moved: {}, warnings: [] };
       const override = aopts.lightsOn !== void 0 ? aopts.lightsOn : info && info.lightsOn;
       if (override !== void 0) {
         for (const e of planned.items) if (e.type === "lamp") e.lit = typeof override === "function" ? !!override(e.id, e) : !!override;
         for (const e of planned.items) if (e.type === "lantern_lamp") e.lit = typeof override === "function" ? !!override(e.id, e) : !!override;
-        for (const e of planned.items) if (e.type === "wall_switch") e.lit = (e.connections.controls || []).some((id) => (planned.items.find((x) => x.id === id) || {}).lit === true);
+        for (const e of planned.items) if (e.type === "wall_switch") e.lit = (e.connections.controls || []).some((id) => planned.items.find((x) => x.id === id)?.lit === true);
       }
       for (const e of planned.items) if (e.type === "lantern_lamp") e.item.on = !!e.lit;
       let scratch = null;
-      function probe(e, hinge, setback) {
+      function probe(e, hinge, setback, blockedAt) {
         if (!scratch) scratch = GI.createWorld({ locale, strings: hh.strings, items: hh.items, loot: hh.loot, grid: false });
-        const it = e.item;
+        const it = at(e.item);
         const x = it.x + Math.sin(it.ry) * setback;
         const z = it.z + Math.cos(it.ry) * setback;
-        const spec = hh.build(e.type, Object.assign({}, it, { hinge }), HH.createRecorder().api);
+        const spec = hh.build(e.type, Object.assign({}, e.item, { hinge }), recorderApi());
         scratch.add("__probe", spec, { x, y: e.floorY, z, ry: it.ry });
-        const blocks = (px, pz) => isBlocked(px, pz, e.floor);
+        const blocks = (px, pz) => blockedAt(px, pz, e.floor);
         let sum = 0;
         let min = 1;
         let n = 0;
         for (const p of spec.parts || []) {
-          if (p.motion.kind !== "hinge" || !(p.bounds || p.sweep)) continue;
+          if (!p.motion || p.motion.kind !== "hinge" || !(p.bounds || p.sweep)) continue;
           const t = scratch.fitSweep("__probe", p.id, blocks);
           sum += t;
           min = Math.min(min, t);
@@ -10538,12 +10657,12 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       const better = (a, b) => a.sum > b.sum + 1e-9 || Math.abs(a.sum - b.sum) <= 1e-9 && a.min > b.min + 1e-9;
       function fitDoors(e) {
         if (!isBlocked || !householdTypes.has(e.type)) return;
-        const standard = probe(e, void 0, 0);
+        const standard = probe(e, void 0, 0, isBlocked);
         if (!standard.n || standard.min >= 1) return;
         let bestSide;
         let m = standard;
         for (const side of ["left", "right"]) {
-          const r = probe(e, side, 0);
+          const r = probe(e, side, 0, isBlocked);
           if (better(r, m)) {
             m = r;
             bestSide = side;
@@ -10556,13 +10675,14 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         if (m.min >= 1) return;
         let target = { setback: 0, r: m };
         for (const setback of [0.01, 0.02, 0.03, 0.04]) {
-          const r = probe(e, bestSide, setback);
+          const r = probe(e, bestSide, setback, isBlocked);
           if (better(r, target.r)) target = { setback, r };
           if (r.min >= 1) break;
         }
         if (target.setback > 0 && target.r.sum > m.sum + 0.2) {
-          e.item.x = r3(e.item.x + Math.sin(e.item.ry) * target.setback);
-          e.item.z = r3(e.item.z + Math.cos(e.item.ry) * target.setback);
+          const p = at(e.item);
+          e.item.x = r3(p.x + Math.sin(p.ry) * target.setback);
+          e.item.z = r3(p.z + Math.cos(p.ry) * target.setback);
           e.moved = target.setback;
           out.moved[e.id] = target.setback;
         }
@@ -10585,7 +10705,8 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
           }
         }
         connect(e, spec);
-        world.add(e.id, spec, { x: e.item.x, y: e.floorY, z: e.item.z, ry: e.item.ry });
+        const pose = at(e.item);
+        world.add(e.id, spec, { x: pose.x, y: e.floorY, z: pose.z, ry: pose.ry });
         out.added++;
         if (!isBlocked) continue;
         for (const p of spec.parts || []) {
@@ -10614,7 +10735,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         return null;
       }
       const A = AD.plan ? AD : AD.create({ ...o.adapterOptions || {}, GameInteractables: GI, GameInteractablesHousehold: HH, locale: o.locale || cfg.locale, region: o.region, ...cfg.seedKey ? { seedKey: cfg.seedKey } : {} });
-      return { GI, HH, GT, A, gfx: GT.createThreeAdapter(THREE, { document: DOC, Reflector }), items: o.items !== false, effects: o.effects !== false, camera: o.camera || null, onEvent: o.onEvent || null, onSeat: o.onSeat || null };
+      return { GI, HH, GT, A, gfx: GT.createThreeAdapter(THREE, { document: DOC, Reflector }), items: o.items !== false, effects: o.effects !== false, effectSink: o.effectSink || null, camera: o.camera || null, onEvent: o.onEvent || null, onSeat: o.onSeat || null };
     })();
     const VEG = (() => {
       const l = cfg.vegetation || null, G = l && (l.GameVegetation || (l.buildLot ? l : null)), S = l && (l.GameVegetationSpecies || (l.toSpec ? l : null));
@@ -10631,7 +10752,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
   // src/lights/room-light.ts
   function installLightsRoomLight(K, shared) {
-    const { THREE, rectsOf: rectsOf2 } = K;
+    const { THREE, rectsOf: rectsOf2, cfg } = K;
     const MAX_LIGHTS = 12, EMPTY = [1e9, 1e9, -1e9, -1e9];
     const LZU = { uRB0: { value: new Float32Array(MAX_LIGHTS * 4) }, uRB1: { value: new Float32Array(MAX_LIGHTS * 4) }, uRB2: { value: new Float32Array(MAX_LIGHTS * 4) }, uRBY: { value: new Float32Array(MAX_LIGHTS * 2) }, uREx: { value: new Float32Array(MAX_LIGHTS * 4) }, uIndK: { value: 0.06 } };
     for (let i = 0; i < MAX_LIGHTS; i++) for (const k of ["uRB0", "uRB1", "uRB2", "uREx"]) LZU[k].value.set(EMPTY, i * 4);
@@ -10670,8 +10791,15 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       o = o || {};
       const scene = o.scene, N = Math.max(1, Math.min(MAX_LIGHTS, o.n || 6)), NS = Math.max(0, Math.min(N, o.shadows != null ? o.shadows : 2)), size = o.shadowSize || 512, MAX_EXTERNAL = o.external != null ? o.external : 2;
       for (const k of Object.keys(shared.mats)) roomLightMask(shared.mats[k]);
+      const budget = o.budget, lease = budget ? budget.lease({ owner: "floorplan.rooms", point: N, shadows: NS }) : null;
+      if (budget && !lease) throw new Error("lighting: the LightBudget has no " + N + " free point slots (" + NS + " with shadow) for the rooms");
+      if (budget) for (const [key, width] of [["uRB0", 4], ["uRB1", 4], ["uRB2", 4], ["uRBY", 2], ["uREx", 4]]) {
+        const next = new Float32Array(budget.sizes.point * width);
+        if (width === 4) for (let i = 0; i < budget.sizes.point; i++) next.set(EMPTY, i * 4);
+        LZU[key].value = next;
+      }
       const PL = [], sig = new Array(N).fill(""), seg = { n: 0 };
-      for (let i = 0; i < N; i++) {
+      if (!lease) for (let i = 0; i < N; i++) {
         const l = new THREE.PointLight(16763008, 0, 8, 1.6);
         l.visible = true;
         l.castShadow = i < NS;
@@ -10687,12 +10815,30 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         if (scene) scene.add(l);
         PL.push(l);
       }
-      const A = { lights: PL, crates: new Array(N).fill(null), n: N, shadows: NS, stats: { rooms: 0, external: 0, shadows: 0, shadowChanged: false }, indirect: (v) => {
+      const slotOf = (i) => lease ? lease.handles[i].slot : i;
+      const put = (i, v) => {
+        if (lease) {
+          lease.handles[i].update(v.color === void 0 || typeof v.color === "number" ? v : { ...v, color: new THREE.Color(v.color).getHex() });
+          return;
+        }
+        const pl = PL[i];
+        if (v.position) pl.position.set(v.position[0], v.position[1], v.position[2]);
+        if (v.color !== void 0) pl.color.set(v.color);
+        if (v.intensity !== void 0) pl.intensity = v.intensity;
+        if (v.distance !== void 0) pl.distance = v.distance;
+        if (v.decay !== void 0) pl.decay = v.decay;
+      };
+      const effects = lease ? effectLights({ budget, ours: lease.handles.map((h) => h.slot) }) : null;
+      const A = { lights: lease ? lease.handles : PL, crates: new Array(N).fill(null), n: N, shadows: NS, stats: { rooms: 0, external: 0, shadows: 0, shadowChanged: false }, indirect: (v) => {
         LZU.uIndK.value = v;
       } };
       const _p = new THREE.Vector3(), _f = new THREE.Vector3();
       const lim = (v, a, b) => Math.max(a, Math.min(b, v));
       A.invalidate = () => {
+        if (lease) {
+          lease.invalidateShadow();
+          return;
+        }
         for (let i = 0; i < NS; i++) PL[i].shadow.needsUpdate = true;
       };
       A.update = function(houses2, focus, op) {
@@ -10800,47 +10946,44 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         A.stats.external = Ne;
         let shadows = 0;
         for (let i = 0; i < N; i++) {
-          const pl = PL[i], g = asg[i], b0 = LZU.uRB0.value, b1 = LZU.uRB1.value, b2 = LZU.uRB2.value, by = LZU.uRBY.value, ex = LZU.uREx.value;
+          const g = asg[i], at2 = slotOf(i), b0 = LZU.uRB0.value, b1 = LZU.uRB1.value, b2 = LZU.uRB2.value, by = LZU.uRBY.value, ex = LZU.uREx.value;
           A.crates[i] = g ? { k: g.k, rects: g.rects, y: g.y, exterior: !!g.exterior, exclusion: g.exclusion || null, d: g.d } : null;
           if (!g) {
-            pl.intensity = 0;
-            for (const a of [b0, b1, b2, ex]) a.set(EMPTY, i * 4);
-            by.set([0, 0], i * 2);
+            put(i, { intensity: 0 });
+            for (const a of [b0, b1, b2, ex]) a.set(EMPTY, at2 * 4);
+            by.set([0, 0], at2 * 2);
             continue;
           }
-          pl.position.set(g.pos[0], g.pos[1], g.pos[2]);
-          pl.color.set(g.color);
-          if (g.exterior) {
-            pl.intensity = g.lumens;
-            pl.distance = g.dist;
-            pl.decay = g.decay;
-          } else {
-            pl.intensity = (7 + g.range * 0.8) * lim(1 + 0.4 * (Math.sqrt(g.n) - 1), 1, 2.2);
-            pl.distance = Math.max(3, g.dm * 1.3 + 0.5);
-            pl.decay = 1.6;
-          }
+          const lamp = g.exterior ? { intensity: g.lumens, distance: g.dist, decay: g.decay } : { intensity: (7 + g.range * 0.8) * lim(1 + 0.4 * (Math.sqrt(g.n) - 1), 1, 2.2), distance: Math.max(3, g.dm * 1.3 + 0.5), decay: 1.6 };
+          put(i, { position: g.pos, color: g.color, ...lamp });
           const rs = g.rects;
-          b0.set(rs[0] || EMPTY, i * 4);
-          b1.set(rs[1] || EMPTY, i * 4);
-          b2.set(rs[2] || EMPTY, i * 4);
-          by.set(g.y, i * 2);
-          ex.set(g.exclusion || EMPTY, i * 4);
+          b0.set(rs[0] || EMPTY, at2 * 4);
+          b1.set(rs[1] || EMPTY, at2 * 4);
+          b2.set(rs[2] || EMPTY, at2 * 4);
+          by.set(g.y, at2 * 2);
+          ex.set(g.exclusion || EMPTY, at2 * 4);
           if (i < NS) {
             shadows++;
             const s2 = g.house.group.uuid + "|" + g.k + "|" + g.pos.map((v) => v.toFixed(2)).join(",");
             if (sig[i] !== s2) {
               sig[i] = s2;
-              pl.shadow.needsUpdate = true;
+              if (lease) lease.invalidateShadow(i);
+              else PL[i].shadow.needsUpdate = true;
               seg.n++;
               A.stats.shadowChanged = true;
             }
-            pl.shadow.camera.far = Math.max(4, pl.distance);
+            if (!lease) PL[i].shadow.camera.far = Math.max(4, lamp.distance);
           }
         }
+        if (effects) effects.update(houses2);
         A.stats.shadows = shadows;
         return A.stats;
       };
       A.dispose = () => {
+        if (lease) {
+          lease.release();
+          return;
+        }
         for (const l of PL) {
           if (l.shadow && l.shadow.map) l.shadow.map.dispose();
           l.removeFromParent();
@@ -10848,59 +10991,116 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       };
       return A;
     }
-    Object.assign(K, { MAX_LIGHTS, EMPTY, LZU, roomLightMask, lighting });
-  }
-  // ../game-contracts/dist/index.js
-  var DEFAULT_IGNITION_RULES = {
-    fillCurve: [
-      [0, 0.6],
-      [0.1, 1],
-      [0.35, 0.6],
-      [0.65, 0.3],
-      [0.9, 0.15],
-      [1, 0.12]
-    ],
-    flameFillInfluence: 0.5,
-    flameDefaults: { incendiary: 0.7, tracer: 0.2 },
-    sparkTarget: { steel: 1, iron: 1, aluminium: 0.25 },
-    sparkMetalDefault: 0.5,
-    sparkFluid: { diesel: 0.15 },
-    fireNear: { radius: 1.5, chancePerSecond: 0.5 }
-  };
-  var resolveIgnitionRules = (rules) => ({
-    ...DEFAULT_IGNITION_RULES,
-    ...rules,
-    flameDefaults: { ...DEFAULT_IGNITION_RULES.flameDefaults, ...rules?.flameDefaults },
-    sparkTarget: { ...DEFAULT_IGNITION_RULES.sparkTarget, ...rules?.sparkTarget },
-    sparkFluid: { ...DEFAULT_IGNITION_RULES.sparkFluid, ...rules?.sparkFluid },
-    fireNear: { ...DEFAULT_IGNITION_RULES.fireNear, ...rules?.fireNear }
-  });
-  var fillFactor = (fill2, curve = DEFAULT_IGNITION_RULES.fillCurve) => {
-    if (curve.length === 0) return 1;
-    const f = Math.min(1, Math.max(0, fill2));
-    if (f <= curve[0][0]) return curve[0][1];
-    for (let i = 1; i < curve.length; i++) {
-      const [x1, y1] = curve[i];
-      const [x0, y0] = curve[i - 1];
-      if (f <= x1) return x1 === x0 ? y1 : y0 + (y1 - y0) * (f - x0) / (x1 - x0);
+    const effectsByBudget = /* @__PURE__ */ new WeakMap();
+    const OPENING_REACH = 2.5, OPENING_SIDE = 0.6;
+    function effectLights(o) {
+      o = o || {};
+      const budget = o.budget;
+      if (!budget) throw new Error("effectLights: a LightBudget is required");
+      const known = effectsByBudget.get(budget);
+      if (known && !o.ours) return known;
+      const ours = new Set(o.ours || []), size = budget.sizes.point, _p = new THREE.Vector3(), P0 = new THREE.Vector3();
+      for (const [key, width] of [["uRB0", 4], ["uRB1", 4], ["uRB2", 4], ["uRBY", 2], ["uREx", 4]]) {
+        const had = LZU[key].value;
+        if (had.length >= size * width) continue;
+        const next = new Float32Array(size * width);
+        if (width === 4) for (let i = 0; i < size; i++) next.set(EMPTY, i * 4);
+        next.set(had);
+        LZU[key].value = next;
+      }
+      const roomBoxes = (house, M) => {
+        const list2 = [];
+        for (const c of house.r.rooms) {
+          if (c.type === "void") continue;
+          const rs = [];
+          for (const [a, b, c2, d] of rectsOf2(c)) {
+            let x0 = 1e9, z0 = 1e9, x1 = -1e9, z1 = -1e9;
+            for (const [u, v] of [[a, b], [c2, b], [a, d], [c2, d]]) {
+              _p.set(u, 0, v).applyMatrix4(M);
+              x0 = Math.min(x0, _p.x);
+              x1 = Math.max(x1, _p.x);
+              z0 = Math.min(z0, _p.z);
+              z1 = Math.max(z1, _p.z);
+            }
+            rs.push([x0 - 0.08, z0 - 0.08, x1 + 0.08, z1 + 0.08]);
+          }
+          _p.set(0, house.y0(c.floor), 0).applyMatrix4(M);
+          list2.push({ c, rs, y: [_p.y - 0.06, _p.y + (c.ceiling || 2.8) + 0.3] });
+        }
+        return list2;
+      };
+      const boxAt = (boxes, x, y, z) => boxes.find((q) => y >= q.y[0] && y <= q.y[1] && q.rs.some((r) => x >= r[0] && x <= r[2] && z >= r[1] && z <= r[3]));
+      const openingSides = (house, M, boxes, into) => {
+        const open = house.internal && house.internal.doorState || /* @__PURE__ */ new Map();
+        const reach = (list2, isDoor) => {
+          for (const p of list2 || []) {
+            if (isDoor && !(open.has(p.id) ? open.get(p.id) : !!p.open)) continue;
+            const alongU = p.axis === "u", y = house.y0(p.floor) + (isDoor ? 1 : ((p.y0 != null ? p.y0 : 0.9) + (p.y1 != null ? p.y1 : 2)) / 2);
+            const at2 = (side) => _p.set(alongU ? p.at : p.pos + side, y, alongU ? p.pos + side : p.at).applyMatrix4(M).clone();
+            if (at2(0).distanceTo(P0) > OPENING_REACH) continue;
+            for (const side of [-OPENING_SIDE, OPENING_SIDE]) {
+              const w = at2(side), hit = boxAt(boxes, w.x, w.y, w.z);
+              if (hit) into.set(hit.c, hit);
+            }
+          }
+        };
+        reach(house.r.doors, true);
+        reach(house.r.windows, false);
+      };
+      const clear = (at2) => {
+        for (const key of ["uRB0", "uRB1", "uRB2", "uREx"]) LZU[key].value.set(EMPTY, at2 * 4);
+        LZU.uRBY.value.set([0, 0], at2 * 2);
+      };
+      const write = (at2, into) => {
+        const rs = [];
+        let lo = 1e9, hi = -1e9;
+        for (const q of into.values()) {
+          rs.push(...q.rs);
+          lo = Math.min(lo, q.y[0]);
+          hi = Math.max(hi, q.y[1]);
+        }
+        while (rs.length > 3) {
+          const r23 = rs.pop(), r1 = rs[rs.length - 1];
+          rs[rs.length - 1] = [Math.min(r1[0], r23[0]), Math.min(r1[1], r23[1]), Math.max(r1[2], r23[2]), Math.max(r1[3], r23[3])];
+        }
+        LZU.uRB0.value.set(rs[0] || EMPTY, at2 * 4);
+        LZU.uRB1.value.set(rs[1] || EMPTY, at2 * 4);
+        LZU.uRB2.value.set(rs[2] || EMPTY, at2 * 4);
+        LZU.uRBY.value.set([lo, hi], at2 * 2);
+        LZU.uREx.value.set(EMPTY, at2 * 4);
+      };
+      const A = {
+        /** Once per frame, after the budget's `present`: points the mask of every lit slot that is not the house's at the rooms its light reaches. */
+        update(houses2) {
+          const indoors = cfg.effectLightsIndoors !== false, list2 = (Array.isArray(houses2) ? houses2 : [houses2]).filter(Boolean), cache2 = /* @__PURE__ */ new Map();
+          for (let at2 = 0; at2 < size; at2++) {
+            if (ours.has(at2)) continue;
+            const light = budget.group.children[at2];
+            if (!indoors || !light || !light.isPointLight || !(light.intensity > 0) || !light.visible) {
+              clear(at2);
+              continue;
+            }
+            const into = /* @__PURE__ */ new Map();
+            P0.set(light.position.x, light.position.y, light.position.z);
+            for (const house of list2) {
+              if (house.group && !house.group.visible) continue;
+              house.house.updateMatrixWorld(true);
+              const M = house.house.matrixWorld;
+              let boxes = cache2.get(house);
+              if (!boxes) cache2.set(house, boxes = roomBoxes(house, M));
+              const here = boxAt(boxes, P0.x, P0.y, P0.z);
+              if (here) into.set(here.c, here);
+              openingSides(house, M, boxes, into);
+            }
+            if (into.size) write(at2, into);
+            else clear(at2);
+          }
+        }
+      };
+      if (!o.ours) effectsByBudget.set(budget, A);
+      return A;
     }
-    return curve[curve.length - 1][1];
-  };
-  var sparkTargetFactor = (materialId, metal, rules = DEFAULT_IGNITION_RULES) => !metal ? 0 : rules.sparkTarget[materialId] ?? rules.sparkMetalDefault;
-  var ignitionChance = (hit, target, rules = DEFAULT_IGNITION_RULES) => {
-    const k = fillFactor(target.fill, rules.fillCurve);
-    const spark = (hit.ignition?.spark ?? 0) * target.sparkTarget * (target.fluid === void 0 ? 1 : rules.sparkFluid[target.fluid] ?? 1) * k;
-    const flameBase = hit.ignition?.flame ?? Math.max(hit.incendiary ? rules.flameDefaults.incendiary : 0, hit.tracer ? rules.flameDefaults.tracer : 0);
-    const flame = flameBase * (1 - rules.flameFillInfluence * (1 - k));
-    return 1 - (1 - Math.min(1, Math.max(0, spark))) * (1 - Math.min(1, Math.max(0, flame)));
-  };
-  var KIT_ORIGIN_KEY = "kitOrigin";
-  function markKitOrigin(object2, origin) {
-    const node = object2;
-    node.userData = node.userData ?? {};
-    node.userData[KIT_ORIGIN_KEY] = { ...origin };
-    return object2;
+    Object.assign(K, { MAX_LIGHTS, EMPTY, LZU, roomLightMask, lighting, effectLights });
   }
   // ../game-destruction/dist/index.js
@@ -11250,11 +11450,11 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     }
     return pieces.slice(0, limit).map((p) => ({ center: p.c, size: [p.s[g], p.s[a], p.s[b]], q: frame(g, a, b), shape: "splinter", weight: p.s[0] * p.s[1] * p.s[2] }));
   };
-  var severAt = (inp, root, at, gap) => {
+  var severAt = (inp, root, at2, gap) => {
     const dims = root.s;
     const L = [0, 1, 2].sort((x, y) => dims[y] - dims[x])[0];
     const half = dims[L] / 2;
-    const lo = clamp(at - gap / 2, -half, half), hi = clamp(at + gap / 2, -half, half);
+    const lo = clamp(at2 - gap / 2, -half, half), hi = clamp(at2 + gap / 2, -half, half);
     const out = [];
     const stub = (from, to) => {
       if (to - from < 0.02) return;
@@ -13613,6 +13813,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     const ignitionRules = resolveIgnitionRules(options.ignition);
     const breachBlastFactor = options.breach?.blastFactor ?? BREACH_BLAST_FACTOR;
     const chipEnergy = options.breach?.chipEnergy ?? CHIP_ENERGY;
+    const chainLinkCap = options.chainLinksPerUpdate !== void 0 && options.chainLinksPerUpdate >= 1 ? Math.floor(options.chainLinksPerUpdate) : Infinity;
     const rng2 = createRng(options.seed ?? 1);
     const rnd = () => rng2.next();
     let time = 0;
@@ -13635,7 +13836,13 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       const typed = listeners.get(e.type);
       if (typed) for (const fn of [...typed]) fn(e);
     };
-    const base = (o, source) => source === void 0 ? { object: o.id, time } : { object: o.id, time, source };
+    let blow;
+    const base = (o, source) => ({
+      object: o.id,
+      time,
+      ...source === void 0 ? {} : { source },
+      ...blow === void 0 ? {} : { blow }
+    });
     const pendingCollapse = /* @__PURE__ */ new Map();
     let runDepth = 0;
     const drainBlasts = () => {
@@ -13905,9 +14112,9 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       const [lo, hi] = contactBox(p, above);
       return toWorld(p.pos, p.q, [(lo[0] + hi[0]) / 2, (lo[1] + hi[1]) / 2, (lo[2] + hi[2]) / 2]);
     };
-    const overSupportAt = (o, p, at, lower) => {
+    const overSupportAt = (o, p, at2, lower) => {
       const g = p.bend;
-      const local = toLocal(p.pos, p.q, at);
+      const local = toLocal(p.pos, p.q, at2);
       const depth = g.gravity >= 0 ? g.dims[g.gravity] : Math.min(...g.depthAxes.map((a) => g.dims[a]));
       let best = -1;
       let bestGap = depth;
@@ -14061,10 +14268,10 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       const incoming = new Array(n).fill(0);
       const bending = new Array(n).fill(0);
       const through = parts.map(() => []);
-      const pass = (k, at, mass) => {
-        const over = overSupportAt(o, parts[k], at, lowerOf.get(k) ?? []);
+      const pass = (k, at2, mass) => {
+        const over = overSupportAt(o, parts[k], at2, lowerOf.get(k) ?? []);
         if (over < 0) bending[k] += mass;
-        else through[k].push({ at, mass, over });
+        else through[k].push({ at: at2, mass, over });
       };
       for (let h = queue.length - 1; h >= 0; h--) {
         const i = queue[h];
@@ -14131,7 +14338,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       const terrain = cfg.terrains.get(cfg.terrain);
       if (!terrain) throw new Error(`unknown wind terrain "${cfg.terrain}"`);
       const inputs = [];
-      const at = /* @__PURE__ */ new Map();
+      const at2 = /* @__PURE__ */ new Map();
       const keep = [];
       let ground = Infinity, foundationTop = -Infinity;
       o.parts.forEach((p, i) => {
@@ -14140,7 +14347,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         const role = p.spec.structure?.role;
         const e = p.mat.strength?.elasticGPa;
         const kind = role === "wall" ? "wall" : role === "column" ? "column" : role === "beam" ? "beam" : role === "foundation" ? "foundation" : "other";
-        at.set(i, inputs.length);
+        at2.set(i, inputs.length);
         keep.push(i);
         ground = Math.min(ground, box3.min[1]);
         if (kind === "foundation") foundationTop = Math.max(foundationTop, box3.max[1]);
@@ -14151,7 +14358,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         const beams = [];
         for (const j of o.byPart.get(o.parts[i].spec.id)) {
           if (j.st.open) continue;
-          const b = at.get(j.ia === i ? j.ib : j.ia);
+          const b = at2.get(j.ia === i ? j.ib : j.ia);
           if (b !== void 0 && inputs[b].kind === "beam") beams.push(b);
         }
         inputs[k].beams = beams;
@@ -14560,7 +14767,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       if (disc < 0) return true;
       return -b - Math.sqrt(disc) > maxDist;
     };
-    const raycastInternal = (origin, dir, maxDist, ignore, worldOnly = false) => {
+    const raycastInternal = (origin, dir, maxDist, ignore, worldOnly = false, precise = false) => {
       const d = vec.normalize(dir);
       let best = null;
       for (const o of objects.values()) {
@@ -14575,13 +14782,25 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         }
       }
       for (const im of worldOnly ? [] : impls.values()) {
+        let boxHit = null;
         for (const ps of im.impl.describe().parts) {
           if (ignore?.has(`${im.impl.id}\0${ps.id}`)) continue;
           const ov = im.poses.get(ps.id);
           const r = rayPartRaw(im.position, im.rotation, ps, ov?.q ?? quatFromEuler(...ps.rotation ?? [0, 0, 0]), origin, d, ov?.pos);
-          if (!r || r.t0 < 0 || r.t0 > maxDist) continue;
-          if (!best || r.t0 < best.distance) best = { object: im.impl.id, part: ps.id, point: vec.madd(origin, d, r.t0), normal: r.n, distance: r.t0, pathLen: r.t1 - r.t0 };
+          if (!r || r.t1 < 0 || r.t0 > maxDist) continue;
+          if (r.t0 < 0) {
+            if (precise && im.impl.surfaceRay) boxHit = boxHit ?? { object: im.impl.id, part: ps.id, point: origin, normal: r.n, distance: 0, pathLen: r.t1 };
+            continue;
+          }
+          if (!boxHit || r.t0 < boxHit.distance) boxHit = { object: im.impl.id, part: ps.id, point: vec.madd(origin, d, r.t0), normal: r.n, distance: r.t0, pathLen: r.t1 - r.t0 };
         }
+        if (!boxHit) continue;
+        if (precise && im.impl.surfaceRay) {
+          const far = best ? Math.min(maxDist, best.distance) : maxDist;
+          const implId = im.impl.id;
+          const s = im.impl.surfaceRay({ origin, direction: d, maxDistance: far, ...ignore ? { ignored: (part) => ignore.has(`${implId}\0${part}`) } : {} });
+          if (s && (!best || s.distance < best.distance)) best = { object: implId, part: s.part, point: s.point, normal: s.normal, distance: s.distance, pathLen: s.pathLen };
+        } else if (!best || boxHit.distance < best.distance) best = boxHit;
       }
       return best;
     };
@@ -14955,7 +15174,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       }
     };
     const tornToEdge = (o) => {
-      const { p, cell, a, b, at, crater: crater2, reach, gone } = o;
+      const { p, cell, a, b, at: at2, crater: crater2, reach, gone } = o;
       const half = p.dims[a] / 2;
       const lo = cell.center[a] - cell.size[a] / 2, hi = cell.center[a] + cell.size[a] / 2;
       const free = (side, sign2) => {
@@ -14963,8 +15182,8 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         const probe = side + sign2 * 1e-3;
         return gridOf(p).some((c, k) => gone(k) && Math.abs(probe - c.center[a]) <= c.size[a] / 2 && Math.abs(cell.center[b] - c.center[b]) <= c.size[b] / 2);
       };
-      if (at - lo <= reach && free(lo, -1)) return [lo, Math.max(crater2[1], lo)];
-      if (hi - at <= reach && free(hi, 1)) return [Math.min(crater2[0], hi), hi];
+      if (at2 - lo <= reach && free(lo, -1)) return [lo, Math.max(crater2[1], lo)];
+      if (hi - at2 <= reach && free(hi, 1)) return [Math.min(crater2[0], hi), hi];
       return crater2;
     };
     const craterAcross = (energy) => clamp2(0.03 + 12e-4 * Math.sqrt(Math.max(0, energy)), 0.03, 0.14);
@@ -15768,7 +15987,17 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       res.events = cur.slice(start);
       return res;
     };
-    const doHit = (o, hit, only) => {
+    const withBlow = (type, fn) => () => {
+      const outer = blow;
+      blow = type;
+      try {
+        return fn();
+      } finally {
+        blow = outer;
+      }
+    };
+    const doHit = (o, hit, only) => withBlow(hit.type, () => resolveHit(o, hit, only))();
+    const resolveHit = (o, hit, only) => {
       let point = hit.point;
       let dir = hit.direction;
       if (hit.space === "local") {
@@ -16065,7 +16294,9 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     };
     const detonatePrimed = (until) => {
       const end = time;
-      for (let next = nextPrimed(until); next; next = nextPrimed(until)) {
+      let fired = 0;
+      for (let next = nextPrimed(until); next && fired < chainLinkCap; next = nextPrimed(until)) {
+        fired++;
         primed.delete(next.p);
         time = Math.max(0, Math.min(end, next.p.rt.chainDue));
         next.p.rt.chainDue = void 0;
@@ -16135,6 +16366,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         updateBound(o);
       },
       remove(id) {
+        impls.get(id)?.impl.dispose?.();
         objects.delete(id);
         impls.delete(id);
       },
@@ -16204,13 +16436,51 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       blastProbe() {
         return { ...blastProbe };
       },
+      blastReach(point, target, options2 = {}) {
+        const L = vec.distance(point, target);
+        if (L < 1e-4) return 1;
+        const shelter = { ...SHELTER_DEFAULTS, ...options2.shelter };
+        const ignore = new Set(options2.ignore ?? []);
+        const d = vec.scale(vec.sub(target, point), 1 / L);
+        let t = 1;
+        for (const o of objects.values()) {
+          if (ignore.has(o.id) || raySphereMiss(point, d, toWorld(o.st.position, o.st.rotation, o.bc), o.br, L)) continue;
+          for (const p of o.parts) {
+            if (isLost(p) || p.st.stripped) continue;
+            const r = rayPart(o, p, point, d);
+            if (!r) continue;
+            const t0 = Math.max(r.t0, 0);
+            const path = Math.min(r.t1, L) - t0;
+            if (path < shelter.minPath) continue;
+            if (p.st.opening && insideOpening(o, p, toLocal(o.st.position, o.st.rotation, vec.madd(point, d, t0 + path / 2)))) continue;
+            t *= Math.exp(-(p.mat.hpPerKg * p.mat.density * path * (p.mat.damageScale?.shelter ?? 1)) / shelter.k);
+            if (t < 1e-4) return 0;
+          }
+        }
+        for (const im of impls.values()) {
+          if (ignore.has(im.impl.id)) continue;
+          for (const ps of im.impl.describe().parts) {
+            const mat = materials.get(ps.material);
+            if (!mat) continue;
+            const ov = im.poses.get(ps.id);
+            const r = rayPartRaw(im.position, im.rotation, ps, ov?.q ?? quatFromEuler(...ps.rotation ?? [0, 0, 0]), point, d, ov?.pos);
+            if (!r || r.t1 < 0 || r.t0 > L) continue;
+            let path = Math.min(r.t1, L) - Math.max(r.t0, 0);
+            if (ps.thickness !== void 0 && ps.thickness > 0) path = Math.min(path, 2 * ps.thickness);
+            else if (path < shelter.minPath) continue;
+            t *= Math.exp(-(mat.hpPerKg * mat.density * path * (mat.damageScale?.shelter ?? 1)) / shelter.k);
+            if (t < 1e-4) return 0;
+          }
+        }
+        return t;
+      },
       explode(point, energy, radius, source, blast) {
         blastProbe.partsTested = 0;
         blastProbe.partsNear = 0;
         return withCollapses(run(() => blastWorld(point, energy, radius, source, blast)));
       },
       raycast(origin, direction, maxDistance = Infinity) {
-        const r = raycastInternal(origin, direction, maxDistance);
+        const r = raycastInternal(origin, direction, maxDistance, void 0, false, true);
         return r ? { object: r.object, part: r.part, point: r.point, normal: r.normal, distance: r.distance } : null;
       },
       sweepBox(box3, direction, distance2, options2 = {}) {
@@ -16228,21 +16498,23 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       },
       shoot(origin, direction, energy, caliber, source, round3) {
         const extras = typeof round3 === "number" ? { piercing: round3 } : round3 ?? {};
-        return withCollapses(run(() => {
+        return withCollapses(run(withBlow("ballistic", () => {
           const results = [];
           const d = vec.normalize(direction);
           const ignore = /* @__PURE__ */ new Set();
           let org = origin;
           let E = energy;
           for (let i = 0; i < 4 && E > 0; i++) {
-            const rh = raycastInternal(org, d, Infinity, ignore);
+            const rh = raycastInternal(org, d, Infinity, ignore, false, true);
             if (!rh) break;
             const im = impls.get(rh.object);
             if (im) {
-              const r = implHit(im, { type: "ballistic", point: rh.point, direction: d, energy: E, caliber, ...extras, ...source !== void 0 ? { source } : {} });
+              const scaled = extras.penetration && E < energy ? { ...extras, penetration: Object.fromEntries(Object.entries(extras.penetration).map(([k, mm]) => [k, mm * (E / energy)])) } : extras;
+              const r = implHit(im, { type: "ballistic", point: rh.point, part: rh.part, normal: rh.normal, direction: d, energy: E, caliber, ...scaled, ...source !== void 0 ? { source } : {} });
               r.part = rh.part;
               r.point = rh.point;
-              r.exitEnergy = r.penetrated ? E * 0.5 : 0;
+              const left = r.events.find((e) => e.type === "hole" && e.energyLeft !== void 0);
+              r.exitEnergy = r.penetrated ? left?.energyLeft ?? E * 0.5 : 0;
               results.push(r);
               ignore.add(`${im.impl.id}\0${rh.part}`);
               if (!r.penetrated) break;
@@ -16261,7 +16533,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
             E = out.exitEnergy;
           }
           return results;
-        }));
+        })));
       },
       disassemble(objectId, jointId, tool, dt) {
         const im = impls.get(objectId);
@@ -16561,12 +16833,27 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       breach: { area: 0.1 }
     }
   ];
+  var SHIPPED = structuredClone(assemblies_default);
   var ASSEMBLIES = assemblies_default;
-  var getAssembly = (id) => ASSEMBLIES.find((a) => a.id === id);
+  var assembliesOver = (defs) => {
+    const get = (id) => defs.find((a) => a.id === id);
+    return {
+      list: () => defs,
+      get,
+      register(def) {
+        const at2 = defs.findIndex((a) => a.id === def.id);
+        if (at2 >= 0) defs[at2] = def;
+        else defs.push(def);
+      },
+      part: (assemblyId, options) => buildAssemblyPart(get(assemblyId), assemblyId, options)
+    };
+  };
+  var defaultSet;
+  var defaultAssemblies = () => defaultSet ?? (defaultSet = assembliesOver(ASSEMBLIES));
+  var getAssembly = (id) => defaultAssemblies().get(id);
   var faceCount = (layer) => layer.faces === "both" ? 2 : 1;
   var assemblyDepth = (def) => def.depth ?? def.core.thickness + (def.layers ?? []).reduce((sum, l) => sum + l.thickness * faceCount(l), 0);
-  var assemblyPart = (assemblyId, options) => {
-    const def = getAssembly(assemblyId);
+  var buildAssemblyPart = (def, assemblyId, options) => {
     if (!def) throw new Error(`unknown assembly "${assemblyId}"`);
     const densityOf2 = (id) => {
       const m = options.materials?.get(id) ?? MATERIALS2.find((x) => x.id === id);
@@ -16593,6 +16880,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       ...options.extra
     };
   };
+  var assemblyPart = (assemblyId, options) => defaultAssemblies().part(assemblyId, options);
   var buildFrame = (o = {}) => {
     const spanX = o.spanX ?? 8, spanZ = o.spanZ ?? 8;
     const nx = Math.max(2, o.columnsX ?? 3), nz = Math.max(2, o.columnsZ ?? 3);
@@ -17625,9 +17913,10 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     }
     if (context.isTimber && construction.roof.shape !== "slab") addCeilingJoists(context);
   }
+  var isStair = (item) => item.category === "stairs" && typeof item.link === "object" && item.link !== null;
   function flightsOf(items) {
     const flights = /* @__PURE__ */ new Map();
-    for (const item of items.filter((it) => it.category === "stairs" && it.link)) {
+    for (const item of items.filter(isStair)) {
       const key = `${item.link.from}_${item.link.to}`;
       if (!flights.has(key) || item.floor === item.link.from) flights.set(key, item);
     }
@@ -19774,6 +20063,34 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
   }
   function installDestructionBreach(K, _shared) {
     const { THREE, fragmentMaterial, invalidate, invalidateShadow } = K;
+    const paintState = { attached: false };
+    const paintQueues = /* @__PURE__ */ new Set();
+    const paintQueue = {
+      id: DEFERRED_QUEUE_ID.BREACH_PAINT,
+      pending: () => {
+        let n = 0;
+        for (const q of paintQueues) n += q.pending();
+        return n;
+      },
+      run(deadline, clock) {
+        let ran = 0;
+        for (const q of [...paintQueues]) {
+          if (q.pending() === 0) continue;
+          if (ran > 0 && clock() >= deadline) break;
+          ran += q.run(deadline, clock);
+        }
+        return ran;
+      },
+      flush() {
+        for (const q of [...paintQueues]) q.flush();
+      },
+      attach() {
+        paintState.attached = true;
+      },
+      detach() {
+        paintState.attached = false;
+      }
+    };
     function createBreachView(opts) {
       const { house, structure } = opts;
       const views = /* @__PURE__ */ new Map();
@@ -19979,17 +20296,17 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         for (const { c, part, units: units2, thick, mid } of shown) {
           if (!near(c)) continue;
           const centre = mask.start + (c.a + c.b) / 2, y = (c.y0 + c.y1) / 2, len = c.b - c.a, h = c.y1 - c.y0;
-          const at = (s, dy, d, colour) => {
+          const at2 = (s, dy, d, colour) => {
             const unit = clipToBox({ x: mask.alongU ? centre : mid, y, z: mask.alongU ? mid : centre, sx: mask.alongU ? s : d, sy: dy, sz: mask.alongU ? d : s, colour }, view.bounds);
             if (unit) list2.push(unit);
           };
           const base = fragmentMaterial(part.material).color.getHex();
           const n = noise2(centre * 3.1, y * 2.7, 0.07);
           if (units2.mortar === "concrete") {
-            at(len, h, thick - 2 * COVER2, tone(base, 0.9 + 0.04 * n));
+            at2(len, h, thick - 2 * COVER2, tone(base, 0.9 + 0.04 * n));
           } else {
-            at(len, h, thick - 2 * COVER2 - 0.012, 10327948);
-            at(len - 0.012, h - 0.012, thick - 2 * COVER2, tone(base, 0.8 + 0.35 * n));
+            at2(len, h, thick - 2 * COVER2 - 0.012, 10327948);
+            at2(len - 0.012, h - 0.012, thick - 2 * COVER2, tone(base, 0.8 + 0.35 * n));
           }
         }
         if (view.units) {
@@ -20088,8 +20405,10 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
           else s.data = collapseRange(s.it.mesh, s.v0, s.it.v1);
         }
       }
-      function flush(budgetMs = paintBudgetMs) {
+      function flush(budgetMs) {
         if (dirty.size === 0) return 0;
+        if (budgetMs === void 0 && paintState.attached) return dirty.size;
+        budgetMs ?? (budgetMs = paintBudgetMs);
         const deadline = performance.now() + budgetMs;
         for (const view of dirty) {
           dirty.delete(view);
@@ -20100,6 +20419,34 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         invalidateShadow();
         return dirty.size;
       }
+      const queue = {
+        id: DEFERRED_QUEUE_ID.BREACH_PAINT,
+        pending: () => dirty.size,
+        run(deadline, clock) {
+          let ran = 0;
+          for (const view of dirty) {
+            dirty.delete(view);
+            paint(view);
+            ran++;
+            if (clock() >= deadline) break;
+          }
+          if (ran > 0) {
+            invalidate();
+            invalidateShadow();
+          }
+          return ran;
+        },
+        flush() {
+          flush(Infinity);
+        },
+        attach() {
+          paintState.attached = true;
+        },
+        detach() {
+          paintState.attached = false;
+        }
+      };
+      paintQueues.add(queue);
       function dispose(view) {
         dirty.delete(view);
         if (view.units) {
@@ -20134,6 +20481,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
          */
         claim() {
           var _a;
+          paintQueues.add(queue);
           for (const q of opts.spec()?.parts ?? []) {
             if (!q.units) continue;
             const host = hostOf(q.id);
@@ -20186,6 +20534,12 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
           dropped.length = 0;
         },
         flush,
+        /** Takes this house's painting out of the renderer's queue (the house goes away); `claim` puts it back. */
+        release() {
+          paintQueues.delete(queue);
+        },
+        /** The painting of this house alone. */
+        deferredQueue: () => queue,
         /** The wall has damage drawn. */
         has(partId) {
           return views.has(partId);
@@ -20200,7 +20554,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         })
       };
     }
-    Object.assign(K, { createBreachView });
+    Object.assign(K, { createBreachView, breachPaintQueue: paintQueue });
   }
   // src/destruction/world.ts
@@ -20268,11 +20622,11 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       };
       const extract = (it) => {
         const g0 = it.mesh.geometry, src = it.mesh.userData._p0 || g0.attributes.position.array, g = new THREE.BufferGeometry();
-        const at = (name, k, arr) => g.setAttribute(name, new THREE.BufferAttribute((arr || g0.attributes[name].array).slice(it.v0 * k, it.v1 * k), k));
-        at("position", 3, src);
-        at("normal", 3);
-        at("color", 3);
-        at("uv", 2);
+        const at2 = (name, k, arr) => g.setAttribute(name, new THREE.BufferAttribute((arr || g0.attributes[name].array).slice(it.v0 * k, it.v1 * k), k));
+        at2("position", 3, src);
+        at2("normal", 3);
+        at2("color", 3);
+        at2("uv", 2);
         const ix = g0.index.array.slice(it.i0, it.i1);
         for (let k = 0; k < ix.length; k++) ix[k] -= it.v0;
         g.setIndex(new THREE.BufferAttribute(ix, 1));
@@ -20455,6 +20809,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         if (R && D.id && D.active) R.unbind(D.id);
         if (D.active && D.world.has(D.id)) D.world.remove(D.id);
         D.active = false;
+        breach.release();
       };
       D.follow = (world, id, spec) => {
         D.spec = spec;
@@ -20489,6 +20844,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         return { restore: () => breach.restore(), dispose: () => {
           offFollow();
           breach.restore();
+          breach.release();
         }, update: () => {
           breach.flush();
         } };
@@ -20985,9 +21341,9 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
             shared.vegMaterials.setActors(focus ? [{ x: focus.x, y: focus.y, z: focus.z, radius: 0.9 }] : []);
           }
           if (focus && cfg.lod !== false) {
-            const L = Object.assign({ interior: 45, hide: 220 }, cfg.lod), d = distance2(focus), at = h.lodCurrent;
+            const L = Object.assign({ interior: 45, hide: 220 }, cfg.lod), d = distance2(focus), at2 = h.lodCurrent;
             let n = d > L.hide ? 2 : d > L.interior ? 1 : 0;
-            if (n < at) n = d < (at === 2 ? L.hide : L.interior) * 0.92 ? n : at;
+            if (n < at2) n = d < (at2 === 2 ? L.hide : L.interior) * 0.92 ? n : at2;
             applyLod(Math.max(n, h.lodMin));
           }
         },
@@ -21101,7 +21457,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
   // src/build/api.ts
   function buildApi(K, shared) {
-    const { cfg, VERSION: VERSION2, ATLAS, TEX, applyPart, carGroup, carModel, props, TYPES, roomLightMask, lighting, newState, build } = K;
+    const { cfg, VERSION: VERSION2, ATLAS, TEX, applyPart, carGroup, carModel, props, TYPES, roomLightMask, lighting, effectLights, newState, build } = K;
     return {
       version: VERSION2,
       build,
@@ -21116,10 +21472,13 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       },
       roomLightMask,
       lighting,
+      effectLights,
       setNight(n) {
         shared.mats.glass.emissive.set(n ? 9067040 : 0);
         shared.mats.glass.opacity = n ? 0.4 : 0.24;
       },
+      /** The chipped-plaster painting of every house of this renderer as a `DeferredQueue` for a frame budget (id `floorplan.breach-paint`); asking for it changes nothing. */
+      deferredQueue: () => K.breachPaintQueue,
       cars: { model: carModel, group: carGroup, info: (k, seed) => {
         const m = carModel(k, seed);
         return m && { parts: m.parts.length, tris: m.tris, L: m.L, W: m.W, H: m.H };
@@ -21586,6 +21945,14 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     return { off, reset: () => navigator.undoChanges(houseId) };
   }
+  // ../game-render-three/dist/index.js
+  var DEFAULT_ANGLE = Math.PI / 3;
+  function isLightBudget(value) {
+    const candidate = value;
+    return typeof candidate === "object" && candidate !== null && typeof candidate.acquire === "function" && typeof candidate.addSource === "function" && typeof candidate.lease === "function" && typeof candidate.present === "function";
+  }
+  var EFFECT_STEP_SECONDS = 1 / 50;
   // src/test-area/text.ts
   var TEXT = {
     en: {
@@ -21608,7 +21975,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         hit: { burst_9mm: "9 mm burst", burst_762: "7.62 burst", sledge: "Sledgehammer", c4: "C4", rpg: "RPG warhead" },
         state: { normal: "Normal", fortified: "Fortified", abandoned: "Abandoned" }
       },
-      layers: { roof: "Roof", lot: "Lot (ground, wall, gate)", night: "Night (lit windows and lamps)" },
+      layers: { roof: "Roof", lot: "Lot (ground, wall, gate)", night: "Night (lit windows and lamps)", room_lights: "Room lights (one lamp per lit room, stopped by the walls)" },
       metrics: { houses: "Houses", parts: "Parts", standing: "Standing", broken: "Broken", holes: "Holes", draw_calls: "Draw calls", triangles: "Triangles", lod: "Level of detail (nearest)", floor: "Your floor", doors_open: "Doors open", target: "You aim at", planned: "Planned draw calls" },
       sheet: { kicker: "House", title: "House of the bench", template: "Typology", seed: "Seed", state: "State", floors: "Floors", size: "Size", parts: "Structure parts", look: "You aim at", none: "nothing to use", no_engine: "The page gave no floorplan engine" },
       specimens: {
@@ -21674,7 +22041,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         hit: { burst_9mm: "Rajada de 9 mm", burst_762: "Rajada de 7,62", sledge: "Marreta", c4: "C4", rpg: "Ogiva de RPG" },
         state: { normal: "Normal", fortified: "Fortificada", abandoned: "Abandonada" }
       },
-      layers: { roof: "Telhado", lot: "Lote (ch\xE3o, muro, port\xE3o)", night: "Noite (janelas e l\xE2mpadas acesas)" },
+      layers: { roof: "Telhado", lot: "Lote (ch\xE3o, muro, port\xE3o)", night: "Noite (janelas e l\xE2mpadas acesas)", room_lights: "Luz por c\xF4modo (uma l\xE2mpada por c\xF4modo aceso, barrada pelas paredes)" },
       metrics: { houses: "Casas", parts: "Pe\xE7as", standing: "De p\xE9", broken: "Quebradas", holes: "Furos", draw_calls: "Draw calls", triangles: "Tri\xE2ngulos", lod: "N\xEDvel de detalhe (a mais perto)", floor: "Seu andar", doors_open: "Portas abertas", target: "Voc\xEA mira em", planned: "Draw calls planejados" },
       sheet: { kicker: "Casa", title: "Casa da bancada", template: "Tipologia", seed: "Semente", state: "Estado", floors: "Andares", size: "Tamanho", parts: "Pe\xE7as da estrutura", look: "Voc\xEA mira em", none: "nada para usar", no_engine: "A p\xE1gina n\xE3o deu o motor de plantas" },
       specimens: {
@@ -21727,14 +22094,14 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
   // src/test-area/scenarios.ts
   var SPECIMEN_AT = [-5, 0, -11];
-  function createHouseScenarios(text, at = SPECIMEN_AT) {
+  function createHouseScenarios(text, at2 = SPECIMEN_AT) {
     const T2 = text.steps;
     const spawn = (room, item) => {
-      const so = room.spawn(item, [at[0], at[1], at[2]], 0);
+      const so = room.spawn(item, [at2[0], at2[1], at2[2]], 0);
       const parts = so.root.userData.floorplanSpec.parts;
       const centre = (id) => {
         const p = parts.find((x) => x.id === id);
-        return [p.position[0] + at[0], p.position[1] + at[1], p.position[2] + at[2]];
+        return [p.position[0] + at2[0], p.position[1] + at2[1], p.position[2] + at2[2]];
       };
       return { oid: so.objectId, parts, centre };
     };
@@ -21971,6 +22338,8 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     let THREE = null;
     let houseRenderer = null;
     let houseRendererKey = "";
+    let stopPaintQueue;
+    let roomLights = null;
     const placed = [];
     let time = 0;
     let dirty = false;
@@ -21998,20 +22367,29 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     const rendererFor = () => {
       const key = `${settings.quality}|${locale}`;
       if (!houseRenderer || houseRendererKey !== key) {
+        stopPaintQueue?.();
+        dropRoomLights();
         houseRenderer?.dispose?.();
         houseRenderer = create3(THREE, {
           locale,
           lod: { interior: 10, hide: 40 },
           breachPaintBudgetMs: 4,
           ...options.house,
+          ...options.house?.interactives ? { interactives: { effectSink: () => host?.effects, ...options.house.interactives } } : {},
           quality: settings.quality,
           ...options.world ? { destruction: options.world } : {},
           ...options.renderer ? { destructionRenderer: options.renderer } : {}
         });
         houseRendererKey = key;
+        const paintQueue = houseRenderer.deferredQueue?.();
+        stopPaintQueue = paintQueue ? host?.defer?.(paintQueue, DEFERRED_PRIORITY[DEFERRED_QUEUE_ID.BREACH_PAINT]) : void 0;
       }
       return houseRenderer;
     };
+    const dropRoomLights = () => {
+      roomLights?.dispose();
+      roomLights = null;
+    };
     const clearHouses = () => {
       for (const p of placed) p.house.dispose();
       placed.length = 0;
@@ -22098,9 +22476,9 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     };
     const eyeOf = (p) => {
       const camera = host?.camera;
-      const at = toLocal2(p, camera.position.x, camera.position.y, camera.position.z);
+      const at2 = toLocal2(p, camera.position.x, camera.position.y, camera.position.z);
       const forward = new THREE.Vector3(0, 0, -1).applyQuaternion(camera.quaternion).transformDirection(new THREE.Matrix4().copy(p.house.group.matrixWorld).invert());
-      return { x: at.x, y: at.y, z: at.z, floor: floorOf(p, camera.position.y), yaw: Math.atan2(forward.x, forward.z), pitch: Math.asin(Math.max(-1, Math.min(1, forward.y))) };
+      return { x: at2.x, y: at2.y, z: at2.z, floor: floorOf(p, camera.position.y), yaw: Math.atan2(forward.x, forward.z), pitch: Math.asin(Math.max(-1, Math.min(1, forward.y))) };
     };
     const blocked = (x, z, radius) => {
       for (const p of placed) {
@@ -22168,7 +22546,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     const doorReach = (p, fo) => {
       const g = fo.gs[0];
       const pivot = fo.handles[0].pivot;
-      const at = (angle) => {
+      const at2 = (angle) => {
         const c = Math.cos(angle);
         const s = Math.sin(angle);
         const v = new THREE.Vector3(pivot[0] * c + pivot[2] * s, pivot[1], -pivot[0] * s + pivot[2] * c).add(g.position);
@@ -22177,8 +22555,8 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       const camera = host?.camera;
       const eye = new THREE.Vector3(camera.position.x, 0, camera.position.z);
       const flat = (v) => Math.hypot(v.x - eye.x, v.z - eye.z);
-      const closed = at(0);
-      const open = at(fo.rot);
+      const closed = at2(0);
+      const open = at2(fo.rot);
       const opening = !fo.open;
       return {
         handle: () => {
@@ -22249,6 +22627,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       }
       if (change.kind === "layer") {
         if (change.id === "roof") showAll();
+        else if (change.id === "room_lights") dropRoomLights();
         else if (placed.length > 0) {
           dirty = true;
           dirtyAt = time;
@@ -22415,7 +22794,8 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       layers: () => [
         { id: "roof", name: text.layers.roof, default: true },
         { id: "lot", name: text.layers.lot, default: false },
-        { id: "night", name: text.layers.night, default: false }
+        { id: "night", name: text.layers.night, default: false },
+        { id: "room_lights", name: text.layers.room_lights, default: false }
       ],
       metrics: () => [
         { id: "houses_built", name: text.metrics.houses, read: () => placed.length },
@@ -22461,6 +22841,21 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
             updateSheet();
           }
         });
+        const stopEffectLights = lent.onFrame(
+          () => {
+            const budget = lent.lights;
+            if (!isLightBudget(budget) || placed.length === 0 || !houseRenderer) return;
+            const houses2 = placed.map((p) => p.house);
+            if (lent.bench?.layer("room_lights") ?? false) {
+              roomLights ?? (roomLights = houseRenderer.lighting({ scene: lent.scene, n: 3, shadows: 0, budget }));
+              roomLights.update(houses2, cameraWorld(), {});
+              return;
+            }
+            dropRoomLights();
+            houseRenderer.effectLights?.({ budget })?.update(houses2);
+          },
+          { phase: "present", order: 20 }
+        );
         const onKey = (event) => {
           if (event.code === "KeyE" && !event.repeat && placed.length > 0) useNearest();
         };
@@ -22468,9 +22863,13 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         return () => {
           stopChange?.();
           stopFrame();
+          stopEffectLights();
+          dropRoomLights();
           globalThis.removeEventListener?.("keydown", onKey);
           for (const remove of removers.splice(0)) remove();
           clearHouses();
+          stopPaintQueue?.();
+          stopPaintQueue = void 0;
           houseRenderer?.dispose?.();
           houseRenderer = null;
           host = null;
@@ -22865,8 +23264,9 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       facadeExtra: (f, rng2, w, d, op) => {
         f.roof = "slab";
         f.finish = rng2() < 0.55 ? "exposed_block" : "partial_plaster";
-        f.slab = { exposedRebar: true, waterTank: { u: r22(0.5 + rng2() * (w - 1.5)), v: r22(1 + rng2() * (d - 2)) }, annex: rng2() < 0.55 ? { rect: [0, 0, r22(w * (0.5 + rng2() * 0.3)), r22(d * 0.4)], state: "exposed_brick" } : null };
-        if (floorsOf(op) > 1) f.slab.exposedRebar = rng2() < 0.6;
+        const slab = { exposedRebar: true, waterTank: { u: r22(0.5 + rng2() * (w - 1.5)), v: r22(1 + rng2() * (d - 2)) }, annex: rng2() < 0.55 ? { rect: [0, 0, r22(w * (0.5 + rng2() * 0.3)), r22(d * 0.4)], state: "exposed_brick" } : null };
+        f.slab = slab;
+        if (floorsOf(op) > 1) slab.exposedRebar = rng2() < 0.6;
       }
     };
   }
@@ -23578,13 +23978,13 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
   function apartment(strip, floor, k, from, to, plate, ceiling, win) {
     const wide = to - from, depth = strip.depth, facade = r22(depth * 0.56);
     const id = (name) => `apt_${floor}_${strip.id}_${k}_${name}`;
-    const at = (f0, f1, b0, b1) => boxOf2(strip, r22(from + wide * f0), r22(from + wide * f1), b0, b1);
+    const at2 = (f0, f1, b0, b1) => boxOf2(strip, r22(from + wide * f0), r22(from + wide * f1), b0, b1);
     const rooms = [
-      { id: id("living"), type: "living", label: "living", library: "living_tower", rect: at(0, 0.58, 0, facade) },
-      { id: id("bedroom"), type: "bedroom", label: "bedroom", rect: at(0.58, 1, 0, facade) },
-      { id: id("kitchen"), type: "kitchen", label: "kitchen", library: "kitchen_integrated", rect: at(0, 0.4, facade, depth) },
-      { id: id("hall"), type: "hall", label: "hall", rect: at(0.4, 0.78, facade, depth) },
-      { id: id("bath"), type: "bathroom", label: "bathroom", library: "bathroom_wc", rect: at(0.78, 1, facade, depth) }
+      { id: id("living"), type: "living", label: "living", library: "living_tower", rect: at2(0, 0.58, 0, facade) },
+      { id: id("bedroom"), type: "bedroom", label: "bedroom", rect: at2(0.58, 1, 0, facade) },
+      { id: id("kitchen"), type: "kitchen", label: "kitchen", library: "kitchen_integrated", rect: at2(0, 0.4, facade, depth) },
+      { id: id("hall"), type: "hall", label: "hall", rect: at2(0.4, 0.78, facade, depth) },
+      { id: id("bath"), type: "bathroom", label: "bathroom", library: "bathroom_wc", rect: at2(0.78, 1, facade, depth) }
     ];
     const doors = [
       stripDoor(id("hall"), strip, floor, 0.95),
@@ -23617,8 +24017,8 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     if (strip.id !== "south") return apartments(plan)(strip, context);
     const { floor, plate, ceiling } = context;
     const lobby = `lobby_${floor}_entrance`, concierge = `concierge_${floor}`, bikes = `bike_room_${floor}`;
-    const at = (f0, f1) => boxOf2(strip, r22(strip.length * f0), r22(strip.length * f1), 0, strip.depth);
-    const [left, middle, right] = [at(0, 0.3), at(0.3, 0.7), at(0.7, 1)];
+    const at2 = (f0, f1) => boxOf2(strip, r22(strip.length * f0), r22(strip.length * f1), 0, strip.depth);
+    const [left, middle, right] = [at2(0, 0.3), at2(0.3, 0.7), at2(0.7, 1)];
     const rooms = [
       { id: concierge, type: "office", label: "concierge", rect: left },
       { id: lobby, type: "hall", label: "lobby_entrance", rect: middle },