@adatechnology/game-urban 0.2.8 → 0.3.1

package/dist/index.global.js

@@ -25,6 +25,7 @@ var GameUrban = (() => {
     DEFAULT_CITY_PLANS: () => DEFAULT_CITY_PLANS,
     DEFAULT_DISTRICT_KINDS: () => DEFAULT_DISTRICT_KINDS,
     DEFAULT_FACADES: () => DEFAULT_FACADES,
+    DEFAULT_LIGHT_ALLOWANCE: () => DEFAULT_LIGHT_ALLOWANCE,
     DEFAULT_LIGHT_BUDGET: () => DEFAULT_LIGHT_BUDGET,
     DEFAULT_MAX_FLOORS: () => DEFAULT_MAX_FLOORS,
     DEFAULT_PATTERNS: () => DEFAULT_PATTERNS,
@@ -44,9 +45,10 @@ var GameUrban = (() => {
     TOWER_DEFAULTS: () => TOWER_DEFAULTS,
     TOWER_PATTERNS: () => TOWER_PATTERNS,
     TOWER_SAMPLE_CELLS: () => TOWER_SAMPLE_CELLS,
-    clamp: () => clamp,
+    clamp: () => clamp2,
     composePattern: () => composePattern,
     createCities: () => createCities,
+    createLightAllowance: () => createLightAllowance,
     createLightBudget: () => createLightBudget,
     createPlantProvider: () => createPlantProvider,
     createSilhouetteHouses: () => createSilhouetteHouses,
@@ -85,37 +87,2297 @@ var GameUrban = (() => {
   });
 
   // src/budget.ts
-  function createLightBudget(count) {
-    const budget = {
+  function createLightAllowance(count) {
+    const allowance = {
       left: count,
       take() {
-        return budget.left-- > 0;
+        return allowance.left-- > 0;
       }
     };
-    return budget;
+    return allowance;
   }
+  var createLightBudget = createLightAllowance;
+
+  // ../game-contracts/dist/index.js
+  var DEFAULT_COST_ALLOCATION_BYTES = 1024 * 1024;
+  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 WARNED_KEY = /* @__PURE__ */ Symbol.for("@adatechnology/game-contracts.warned");
+  var warnedKeys = () => {
+    const holder = globalThis;
+    return holder[WARNED_KEY] ?? (holder[WARNED_KEY] = /* @__PURE__ */ new Set());
+  };
+  var isProduction = () => {
+    try {
+      return process.env.NODE_ENV === "production";
+    } catch {
+      return false;
+    }
+  };
+  var isQuiet = () => globalThis.__GAME_KIT_QUIET__ === true;
+  var warnOnce = (key, message) => {
+    if (isQuiet() || isProduction()) return;
+    const seen = warnedKeys();
+    if (seen.has(key)) return;
+    seen.add(key);
+    console.warn(`[game-kit] ${message}`);
+  };
+  var UNSAFE_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+  var isPlainObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value) && Object.getPrototypeOf(value) === Object.prototype;
+  var deepMerge = (base, patch) => {
+    if (!patch) return base;
+    const result = { ...base };
+    for (const [key, value] of Object.entries(patch)) {
+      if (value === void 0 || UNSAFE_KEYS.has(key)) continue;
+      const current = result[key];
+      result[key] = isPlainObject(current) && isPlainObject(value) ? deepMerge(current, value) : value;
+    }
+    return result;
+  };
+  var mergeById = (shipped, extra) => {
+    const entries = /* @__PURE__ */ new Map();
+    for (const entry of [...shipped, ...extra ?? []]) entries.set(entry.id, entry);
+    return entries;
+  };
+  var applyPatches = (entries, patches) => {
+    for (const [id, patch] of Object.entries(patches ?? {})) {
+      const entry = entries.get(id);
+      if (entry) entries.set(id, deepMerge(entry, patch));
+      else warnOnce(`registry.patch.${id}`, `patch for "${id}" ignored: no entry has that id`);
+    }
+  };
+  var removeIds = (entries, ids) => {
+    for (const id of ids ?? []) {
+      if (!entries.delete(id)) warnOnce(`registry.remove.${id}`, `remove of "${id}" ignored: no entry has that id`);
+    }
+  };
+  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-floorplan/dist/index.js
-  var WALL_THICKNESS = 0.15;
-  var MARGIN = WALL_THICKNESS / 2;
-  var CATALOG = {};
+  var createRegistries = () => ({
+    CATALOG: {},
+    LIBRARIES: {},
+    LIBRARY_ALIAS: {},
+    TEMPLATES: {},
+    STYLES: {},
+    STYLE_ALIAS: {},
+    PALETTE_STYLES: {},
+    ROOM_COLORS: [],
+    PASSES: [],
+    DECOR_PROFILES: {},
+    GROUND_OVERLAYS: [],
+    STATE_PLUGINS: { normal: { apply: () => [] } },
+    WALL_TOP_HEIGHTS: { none: 0 },
+    SEED_KEYS: { rooms: {}, items: {} },
+    stateDistribution: { weights: null, seedKey: "state" },
+    RESULT_EXTENSIONS: [],
+    FINDS_PROVIDERS: [],
+    VIEWER_LAYERS: [],
+    LOCALES: {},
+    ZONES: {},
+    PERMEABLE_GROUNDS: /* @__PURE__ */ new Set()
+  });
+  var defaultRegistries;
+  var activeRegistries;
+  var getDefaultRegistries = () => defaultRegistries ?? (defaultRegistries = createRegistries());
+  var registries = () => activeRegistries ?? getDefaultRegistries();
+  function withRegistries(scope, run) {
+    const previous = activeRegistries;
+    activeRegistries = scope;
+    try {
+      return run();
+    } finally {
+      activeRegistries = previous;
+    }
+  }
   function registerItem(def) {
     const h = def.h;
     const item = Object.assign({ front: "+z", window: h <= 0.95, low: h <= 0.5, flat: false, deck: false, rim: 0 }, def);
-    CATALOG[def.type] = item;
+    registries().CATALOG[def.type] = item;
     return item;
   }
   function registerItems(list) {
     for (const d of list) registerItem(d);
   }
-  var locales = {};
+  function registerLibrary(id, library) {
+    registries().LIBRARIES[id] = library;
+  }
+  function registerLibraryAlias(alias, id) {
+    registries().LIBRARY_ALIAS[alias] = id;
+  }
+  function registerTemplate(t) {
+    registries().TEMPLATES[t.id] = t;
+    return t;
+  }
+  function registerStyle(style) {
+    registries().STYLES[style.id] = style;
+    for (const a of style.aliases || []) registries().STYLE_ALIAS[a] = style.id;
+  }
+  function registerPaletteStyle(id, def) {
+    registries().PALETTE_STYLES[id] = def;
+  }
+  function registerRoomColors(list) {
+    for (const d of list) {
+      const i = registries().ROOM_COLORS.findIndex((x) => x.type === d.type);
+      if (i >= 0) registries().ROOM_COLORS.splice(i, 1);
+      registries().ROOM_COLORS.push(d);
+    }
+    registries().ROOM_COLORS.sort((a, b) => a.order - b.order);
+  }
+  function registerDecorProfile(styleId, profile) {
+    registries().DECOR_PROFILES[styleId] = profile;
+  }
+  function registerPass(name, run) {
+    const i = registries().PASSES.findIndex((p) => p.name === name);
+    if (i >= 0) registries().PASSES[i] = { name, run };
+    else registries().PASSES.push({ name, run });
+  }
+  function registerGroundOverlay(rule) {
+    registries().GROUND_OVERLAYS.push(rule);
+  }
+  function registerWallTop(id, height) {
+    registries().WALL_TOP_HEIGHTS[id] = height;
+  }
+  function registerSeedKeys(keys) {
+    Object.assign(registries().SEED_KEYS.rooms, keys.rooms);
+    Object.assign(registries().SEED_KEYS.items, keys.items);
+  }
+  function registerState(name, plugin) {
+    registries().STATE_PLUGINS[name] = plugin;
+  }
+  function setStateDistribution(weights, seedKey = "state") {
+    registries().stateDistribution.weights = weights;
+    registries().stateDistribution.seedKey = seedKey;
+  }
+  var listStates = () => Object.keys(registries().STATE_PLUGINS);
+  function resolveStyleId(id) {
+    const s = id ?? "";
+    return registries().STYLE_ALIAS[s] ?? s;
+  }
+  function styleOf(id) {
+    return registries().STYLES[id] || registries().STYLES.budget || Object.values(registries().STYLES)[0];
+  }
+  function registerResultExtension(name, run, options = {}) {
+    const entry = { name, run, after: options.after || [], seedKey: options.seedKey ?? name };
+    const i = registries().RESULT_EXTENSIONS.findIndex((x) => x.name === name);
+    if (i >= 0) registries().RESULT_EXTENSIONS[i] = entry;
+    else registries().RESULT_EXTENSIONS.push(entry);
+  }
+  function registerFindsProvider(provider) {
+    registries().FINDS_PROVIDERS.push(provider);
+  }
+  function registerViewerLayer(layer) {
+    const i = registries().VIEWER_LAYERS.findIndex((x) => x.id === layer.id);
+    if (i >= 0) registries().VIEWER_LAYERS[i] = layer;
+    else registries().VIEWER_LAYERS.push(layer);
+  }
+  function mulberry32(a) {
+    return function() {
+      a |= 0;
+      a = a + 1831565813 | 0;
+      let t = Math.imul(a ^ a >>> 15, 1 | a);
+      t = t + Math.imul(t ^ t >>> 7, 61 | t) ^ t;
+      return ((t ^ t >>> 14) >>> 0) / 4294967296;
+    };
+  }
+  function hashString(input) {
+    const s = String(input);
+    let h = 1779033703 ^ s.length;
+    for (let i = 0; i < s.length; i++) {
+      h = Math.imul(h ^ s.charCodeAt(i), 3432918353);
+      h = h << 13 | h >>> 19;
+    }
+    h = Math.imul(h ^ h >>> 16, 2246822507);
+    h = Math.imul(h ^ h >>> 13, 3266489909);
+    return (h ^ h >>> 16) >>> 0;
+  }
+  var createRng = (seed, key) => mulberry32(hashString(seed + "|" + key));
+  function pickWeighted(rng, weights) {
+    const keys = Object.keys(weights);
+    let total = 0;
+    for (const k of keys) total += weights[k];
+    let x = rng() * total;
+    for (const k of keys) {
+      x -= weights[k];
+      if (x < 0) return k;
+    }
+    return keys[keys.length - 1];
+  }
+  function weightedOrder(candidates, rng) {
+    const arr = candidates.slice();
+    const out = [];
+    while (arr.length) {
+      let total = 0;
+      for (const c of arr) total += c.weight;
+      let x = rng() * total;
+      let i = 0;
+      for (; i < arr.length - 1; i++) {
+        x -= arr[i].weight;
+        if (x < 0) break;
+      }
+      out.push(arr.splice(i, 1)[0]);
+    }
+    return out;
+  }
+  function shuffle(arr, rng) {
+    const a = arr.slice();
+    for (let i = a.length - 1; i > 0; i--) {
+      const j = Math.floor(rng() * (i + 1));
+      [a[i], a[j]] = [a[j], a[i]];
+    }
+    return a;
+  }
+  function orderOf(extensions) {
+    const ordered = [];
+    const visiting = /* @__PURE__ */ new Set();
+    const visit = (extension) => {
+      if (ordered.includes(extension)) return;
+      if (visiting.has(extension.name)) throw new Error("Result extensions depend on each other: " + extension.name);
+      visiting.add(extension.name);
+      for (const name of extension.after) {
+        const before = extensions.find((x) => x.name === name);
+        if (before) visit(before);
+      }
+      visiting.delete(extension.name);
+      ordered.push(extension);
+    };
+    extensions.forEach(visit);
+    return ordered;
+  }
+  function runResultExtensions(plan, result, seed, options) {
+    for (const extension of orderOf(registries().RESULT_EXTENSIONS)) {
+      result[extension.name] = extension.run({ plan, result, seed, rng: createRng(seed, extension.seedKey), options });
+    }
+  }
+  function findsFor(query) {
+    return answerOf(query) ?? [];
+  }
+  function findsAnswer(query) {
+    return answerOf(query);
+  }
+  function answerOf(query) {
+    for (const provider of registries().FINDS_PROVIDERS) {
+      const stacks = provider.findsFor(query);
+      if (stacks !== null) return stacks;
+    }
+    return null;
+  }
+  var WALL_THICKNESS = 0.15;
+  var MARGIN = WALL_THICKNESS / 2;
+  var EPS = 1e-6;
+  var TOL = 1e-3;
+  var DOOR_CLEARANCE = 0.9;
+  var PLAYER_RADIUS = 0.24;
+  var DOOR_EDGE_CLEARANCE = 0.12;
+  var WINDOW_EDGE_CLEARANCE = 0.3;
+  var OVERHEAD_TOP = 2.15;
+  var WINDOWLESS_ROOM_TYPES = /* @__PURE__ */ new Set([
+    "stockroom",
+    "kitchen",
+    "laundry",
+    "bathroom",
+    "void",
+    "elevator",
+    "stairs",
+    "pantry",
+    "closet",
+    "corridor",
+    "hall",
+    "balcony",
+    "terrace",
+    "garage",
+    "storage",
+    "porch",
+    "tent",
+    "outhouse"
+  ]);
+  var CAR_CLEARANCE = { driver: 0.8, side: 0.6, end: 0.6 };
+  var r2 = (x) => Math.round(x * 100) / 100;
+  var clamp = (x, a, b) => Math.max(a, Math.min(b, x));
+  var overlaps = (a, b, e = EPS) => a[0] < b[2] - e && a[2] > b[0] + e && a[1] < b[3] - e && a[3] > b[1] + e;
+  var inner = (p) => [p[0] + MARGIN, p[1] + MARGIN, p[2] - MARGIN, p[3] - MARGIN];
+  var eq = (a, b) => Math.abs(a - b) < TOL;
+  var inflate = (r, e) => [r[0] - e, r[1] - e, r[2] + e, r[3] + e];
+  var areaOf = (r) => (r[2] - r[0]) * (r[3] - r[1]);
+  var topOf = (m) => (m.y || 0) + m.h;
+  var extent = (size, f) => Math.abs(f[1]) === 1 ? [size[0], size[1]] : [size[1], size[0]];
+  var cardinal = (dx, dz) => Math.abs(dx) > Math.abs(dz) ? [Math.sign(dx), 0] : [0, Math.sign(dz) || 1];
+  function clearRect(r, f, clearance) {
+    return f[1] === 1 ? [r[0], r[3], r[2], r[3] + clearance] : f[1] === -1 ? [r[0], r[1] - clearance, r[2], r[1]] : f[0] === 1 ? [r[2], r[1], r[2] + clearance, r[3]] : [r[0] - clearance, r[1], r[0], r[3]];
+  }
+  function insideUnion(r, inners) {
+    const e = 1e-4;
+    const points = [
+      [r[0] + e, r[1] + e],
+      [r[2] - e, r[1] + e],
+      [r[0] + e, r[3] - e],
+      [r[2] - e, r[3] - e],
+      [(r[0] + r[2]) / 2, (r[1] + r[3]) / 2]
+    ];
+    return points.every((p) => inners.some((q) => p[0] >= q[0] - 1e-6 && p[0] <= q[2] + 1e-6 && p[1] >= q[1] - 1e-6 && p[1] <= q[3] + 1e-6));
+  }
+  function cutIntervals(intervals, a, b) {
+    const out = [];
+    for (const [x, y] of intervals) {
+      if (b <= x || a >= y) {
+        out.push([x, y]);
+        continue;
+      }
+      if (a > x) out.push([x, a]);
+      if (b < y) out.push([b, y]);
+    }
+    return out;
+  }
+  function exteriorEdge(room, side, w, d, c) {
+    const cand = [];
+    for (const p of room.parts) {
+      if (side === "front" && eq(p[1], 0)) cand.push({ axis: "u", pos: 0, a0: p[0], a1: p[2] });
+      else if (side === "back" && eq(p[3], d)) cand.push({ axis: "u", pos: d, a0: p[0], a1: p[2] });
+      else if (side === "left" && eq(p[0], 0)) cand.push({ axis: "v", pos: 0, a0: p[1], a1: p[3] });
+      else if (side === "right" && eq(p[2], w)) cand.push({ axis: "v", pos: w, a0: p[1], a1: p[3] });
+    }
+    if (!cand.length) return null;
+    if (c != null) {
+      const k = cand.find((x) => c >= x.a0 - TOL && c <= x.a1 + TOL);
+      if (k) return k;
+    }
+    return cand.sort((x, y) => y.a1 - y.a0 - (x.a1 - x.a0))[0];
+  }
+  function sharedEdge(A, B, c) {
+    const cand = [];
+    for (const pa of A.parts)
+      for (const pb of B.parts) {
+        let o;
+        if (eq(pa[2], pb[0]) || eq(pa[0], pb[2])) {
+          o = [Math.max(pa[1], pb[1]), Math.min(pa[3], pb[3])];
+          if (o[1] - o[0] > TOL) cand.push({ axis: "v", pos: eq(pa[2], pb[0]) ? pa[2] : pa[0], a0: o[0], a1: o[1] });
+        }
+        if (eq(pa[3], pb[1]) || eq(pa[1], pb[3])) {
+          o = [Math.max(pa[0], pb[0]), Math.min(pa[2], pb[2])];
+          if (o[1] - o[0] > TOL) cand.push({ axis: "u", pos: eq(pa[3], pb[1]) ? pa[3] : pa[1], a0: o[0], a1: o[1] });
+        }
+      }
+    if (!cand.length) return null;
+    if (c != null) {
+      const k = cand.find((x) => c >= x.a0 - TOL && c <= x.a1 + TOL);
+      if (k) return k;
+    }
+    return cand.sort((x, y) => y.a1 - y.a0 - (x.a1 - x.a0))[0];
+  }
+  function openingZones(u, v, axis, width, depth) {
+    const h = width / 2;
+    return axis === "u" ? [[u - h, v - depth, u + h, v], [u - h, v, u + h, v + depth]] : [[u - depth, v - h, u, v + h], [u, v - h, u + depth, v + h]];
+  }
+  var openingDepth = (width, leaf) => Math.max(0.9, leaf) + MARGIN;
+  function entryPoints(ab) {
+    return ab.axis === "u" ? [[ab.u, ab.v - 0.55], [ab.u, ab.v + 0.55]] : [[ab.u - 0.55, ab.v], [ab.u + 0.55, ab.v]];
+  }
+  function normalizeRoom(c, floorIndex) {
+    const parts = [c.rect].concat(c.parts || []).map((p) => p.map(r2));
+    return {
+      id: c.id,
+      type: c.type,
+      label: c.label,
+      floor: floorIndex,
+      parts,
+      library: c.library || null,
+      without: c.without || [],
+      overrides: c.overrides || {},
+      extras: c.extras || [],
+      slots: c.slots || null,
+      link: c.link || null,
+      outdoor: !!c.outdoor,
+      ceiling: c.ceiling || null,
+      seedKey: c.seedKey
+    };
+  }
+  function usableParts(room, extra) {
+    const m = MARGIN + (extra || 0);
+    const out = [];
+    for (const p of room.parts) {
+      out.push([p[0] + m, p[1] + m, p[2] - m, p[3] - m]);
+      for (let k = 0; k < 4; k++) {
+        const spans = [];
+        for (const q of room.parts) {
+          if (q === p) continue;
+          if (k === 0 && eq(q[2], p[0])) spans.push([Math.max(q[1], p[1]), Math.min(q[3], p[3])]);
+          else if (k === 2 && eq(q[0], p[2])) spans.push([Math.max(q[1], p[1]), Math.min(q[3], p[3])]);
+          else if (k === 1 && eq(q[3], p[1])) spans.push([Math.max(q[0], p[0]), Math.min(q[2], p[2])]);
+          else if (k === 3 && eq(q[1], p[3])) spans.push([Math.max(q[0], p[0]), Math.min(q[2], p[2])]);
+        }
+        spans.sort((x, y) => x[0] - y[0]);
+        const merged = [];
+        for (const span of spans) {
+          const last = merged[merged.length - 1];
+          if (last && span[0] <= last[1] + TOL) last[1] = Math.max(last[1], span[1]);
+          else merged.push([span[0], span[1]]);
+        }
+        for (const [a, b] of merged) {
+          if (b - a <= 0.3) continue;
+          const x0 = a + m;
+          const x1 = b - m;
+          if (x1 <= x0) continue;
+          if (k === 0) out.push([p[0], x0, p[0] + m, x1]);
+          else if (k === 2) out.push([p[2] - m, x0, p[2], x1]);
+          else if (k === 1) out.push([x0, p[1], x1, p[1] + m]);
+          else out.push([x0, p[3] - m, x1, p[3]]);
+        }
+      }
+    }
+    return out;
+  }
+  var inRect = (room, u, v) => room.parts.some((p) => u > p[0] + EPS && u < p[2] - EPS && v > p[1] + EPS && v < p[3] - EPS);
+  function buildWalls(rooms, doors, openPairs, floorIndex) {
+    const groups = {};
+    const add = (axis, pos, a, b, id, side) => {
+      const k = axis + "|" + pos.toFixed(2);
+      (groups[k] = groups[k] || { axis, pos, es: [] }).es.push({ a, b, id, side });
+    };
+    for (const c of rooms)
+      for (const p of c.parts) {
+        add("u", p[1], p[0], p[2], c.id, 1);
+        add("u", p[3], p[0], p[2], c.id, -1);
+        add("v", p[0], p[1], p[3], c.id, 1);
+        add("v", p[2], p[1], p[3], c.id, -1);
+      }
+    const par = (x, y) => openPairs.some((o) => o[0] === x && o[1] === y || o[0] === y && o[1] === x);
+    const typeOf = {};
+    for (const c of rooms) typeOf[c.id] = c.type;
+    const out = [];
+    for (const g of Object.values(groups)) {
+      const breaks = [...new Set(g.es.flatMap((e) => [r2(e.a), r2(e.b)]))].sort((x, y) => x - y);
+      const segs = [];
+      for (let i = 0; i < breaks.length - 1; i++) {
+        const p = breaks[i];
+        const q = breaks[i + 1];
+        const m = (p + q) / 2;
+        const after = g.es.find((e) => e.side === 1 && m > e.a && m < e.b);
+        const before = g.es.find((e) => e.side === -1 && m > e.a && m < e.b);
+        if (!after && !before) continue;
+        const A = before ? before.id : "outside";
+        const B = after ? after.id : "outside";
+        if (A === B || A !== "outside" && B !== "outside" && par(A, B)) continue;
+        const last = segs[segs.length - 1];
+        if (last && last.A === A && last.B === B && eq(last.q, p)) last.q = q;
+        else segs.push({ A, B, p, q });
+      }
+      for (const s of segs) {
+        let pieces = [[s.p, s.q]];
+        for (const pt of doors) {
+          if (pt.axis !== g.axis || !eq(pt.pos, g.pos)) continue;
+          const c0 = pt.at - pt.width / 2;
+          const c1 = pt.at + pt.width / 2;
+          const n = [];
+          for (const [x, y] of pieces) {
+            if (c1 <= x + TOL || c0 >= y - TOL) {
+              n.push([x, y]);
+              continue;
+            }
+            if (c0 > x + TOL) n.push([x, c0]);
+            if (c1 < y - TOL) n.push([c1, y]);
+          }
+          pieces = n;
+        }
+        for (const [x, y] of pieces) {
+          const isOpen = (t) => t === "balcony" || t === "terrace" || t === "porch";
+          const isVoid = typeOf[s.A] === "void" || typeOf[s.B] === "void";
+          if (isVoid && (s.A === "outside" || s.B === "outside")) continue;
+          const railing = isVoid || isOpen(typeOf[s.A]) && s.B === "outside" || isOpen(typeOf[s.B]) && s.A === "outside";
+          out.push({
+            floor: floorIndex,
+            axis: g.axis,
+            u0: g.axis === "u" ? x : g.pos,
+            v0: g.axis === "u" ? g.pos : x,
+            u1: g.axis === "u" ? y : g.pos,
+            v1: g.axis === "u" ? g.pos : y,
+            thickness: WALL_THICKNESS,
+            sides: [s.A, s.B],
+            exterior: s.A === "outside" || s.B === "outside",
+            type: railing ? "railing" : "wall",
+            h: railing ? 1.1 : 0
+          });
+        }
+      }
+    }
+    return out;
+  }
+  var STEP = 0.05;
+  var MAX_CANDIDATES = 80;
+  function carCandidates(slot, item, car) {
+    const front = [slot.frontU, slot.frontV];
+    if (!slot._cell) throw new Error("Slot without a cell: " + slot.id);
+    const zone = slot._cell.R;
+    const alongV = Math.abs(front[1]) === 1;
+    const [extentU, extentV] = extent([item.w, item.d], front);
+    const across = alongV ? extentU : extentV;
+    const along = alongV ? extentV : extentU;
+    const a = alongV ? 0 : 1;
+    const b = alongV ? 1 : 0;
+    const driverSign = alongV ? front[1] : -front[0];
+    const frontSign = alongV ? front[1] : front[0];
+    const lowClear = driverSign < 0 ? car.driver : car.side;
+    const highClear = driverSign < 0 ? car.side : car.driver;
+    const lo = zone[a] + lowClear;
+    const hi = zone[a + 2] - highClear - across;
+    const alongLo = zone[b] + car.end;
+    const alongHi = zone[b + 2] - car.end - along;
+    if (hi < lo - 1e-6 || alongHi < alongLo - 1e-6) return [];
+    const preferred = (alongV ? slot.x : slot.z) - across / 2;
+    const alongStart = frontSign < 0 ? alongHi : alongLo;
+    const positions = [];
+    for (let p = lo; p <= hi + 1e-6; p += STEP) positions.push(Math.min(p, hi));
+    positions.sort((x, y) => Math.abs(x - preferred) - Math.abs(y - preferred));
+    return positions.slice(0, MAX_CANDIDATES).map((p) => {
+      const rect = alongV ? [p, alongStart, p + across, alongStart + along] : [alongStart, p, alongStart + along, p + across];
+      const clear = alongV ? [p - lowClear, alongStart - car.end, p + across + highClear, alongStart + along + car.end] : [alongStart - car.end, p - lowClear, alongStart + along + car.end, p + across + highClear];
+      return { rect, clear };
+    });
+  }
+  function zonesOfFloor(plan, floorIndex) {
+    const out = [];
+    if (floorIndex >= 0) {
+      for (const p of plan.doors) if (p.floor === floorIndex) out.push(...p.zones);
+    } else {
+      for (const p of plan.doors) if (p.floor === 0 && p.exterior) out.push(...p.zones);
+      for (const g of plan.gates) out.push(...g.zones);
+      for (const c of plan.paths) out.push(...c.rects);
+      out.push(...plan.reservations);
+    }
+    return out;
+  }
+  function openingsOfFloor(plan, floorIndex) {
+    if (floorIndex >= 0) return plan.doors.filter((p) => p.floor === floorIndex);
+    return plan.doors.filter((p) => p.floor === 0 && p.exterior).concat(plan.gates);
+  }
+  function windowZone(j, outside) {
+    const h = j.width / 2 + 0.1;
+    const depth = 0.5;
+    let n;
+    if (j.side === "front") n = [0, 1];
+    else if (j.side === "back") n = [0, -1];
+    else if (j.side === "left") n = [1, 0];
+    else n = [-1, 0];
+    if (outside) n = [-n[0], -n[1]];
+    const u = j.u;
+    const v = j.v;
+    if (j.axis === "u") return n[1] > 0 ? [u - h, v - MARGIN, u + h, v + depth] : [u - h, v - depth, u + h, v + MARGIN];
+    return n[0] > 0 ? [u - MARGIN, v - h, u + depth, v + h] : [u - depth, v - h, u + MARGIN, v + h];
+  }
+  function blocksWindow(it, win, overheadOff) {
+    const height = Math.max(it.h, it.windowHeight || 0, it.overhead && !overheadOff ? OVERHEAD_TOP : 0);
+    return !it.window || it.h > 1 + EPS || height > win.y0 - 0.05 + EPS;
+  }
+  function windowsOfRoom(plan, room) {
+    if (!room.outdoor) return plan.windows.filter((j) => j.room === room.id);
+    return plan.windows.filter(
+      (j) => j.floor === 0 && room.parts.some((p) => {
+        if (j.side === "front") return eq(p[3], j.pos) && j.u >= p[0] && j.u <= p[2];
+        if (j.side === "back") return eq(p[1], j.pos) && j.u >= p[0] && j.u <= p[2];
+        if (j.side === "left") return eq(p[2], j.pos) && j.v >= p[1] && j.v <= p[3];
+        return eq(p[0], j.pos) && j.v >= p[1] && j.v <= p[3];
+      })
+    );
+  }
+  function roomAt(plan, u, v, floorIndex) {
+    const list = floorIndex < 0 ? plan.zones : plan.rooms;
+    return list.find((c) => c.floor === floorIndex && inRect(c, u, v)) || null;
+  }
+  function isOpenSide(plan, room, pu, pv) {
+    const o = roomAt(plan, pu, pv, room.floor);
+    if (!o) return false;
+    if (o.id === room.id) return true;
+    if (room.outdoor) return true;
+    return (plan.openPairs[room.floor] || []).some((x) => x[0] === room.id && x[1] === o.id || x[1] === room.id && x[0] === o.id);
+  }
+  function wallBodies(plan, floor) {
+    const cache = plan.wallBodies = plan.wallBodies || {};
+    if (cache[floor]) return cache[floor];
+    const doors = plan.doors.filter((p) => p.floor === floor);
+    return cache[floor] = plan.walls.filter((p) => p.floor === floor && (p.type === "wall" || p.type === "railing")).map((p) => {
+      const a0 = p.axis === "u" ? p.u0 : p.v0;
+      const a1 = p.axis === "u" ? p.u1 : p.v1;
+      const pos = p.axis === "u" ? p.v0 : p.u0;
+      const atDoor = (x) => doors.some((q) => q.axis === p.axis && eq(q.pos, pos) && (eq(q.at - q.width / 2, x) || eq(q.at + q.width / 2, x)));
+      const e0 = atDoor(a0) ? 0 : MARGIN;
+      const e1 = atDoor(a1) ? 0 : MARGIN;
+      return p.axis === "u" ? [a0 - e0, pos - MARGIN, a1 + e1, pos + MARGIN] : [pos - MARGIN, a0 - e0, pos + MARGIN, a1 + e1];
+    });
+  }
+  function createGrid(plan, room, ignored, radius = plan.playerRadius) {
+    const gs = room.outdoor ? 0.3 : 0.1;
+    let u0 = 1e9;
+    let v0 = 1e9;
+    let u1 = -1e9;
+    let v1 = -1e9;
+    for (const p of room.parts) {
+      u0 = Math.min(u0, p[0]);
+      v0 = Math.min(v0, p[1]);
+      u1 = Math.max(u1, p[2]);
+      v1 = Math.max(v1, p[3]);
+    }
+    const nx = Math.ceil((u1 - u0) / gs);
+    const nz = Math.ceil((v1 - v0) / gs);
+    const insideCells = new Uint8Array(nx * nz);
+    const insets = room.outdoor ? usableParts(room, 0.08) : room.parts;
+    const bodies = room.outdoor ? null : wallBodies(plan, room.floor).filter((r) => r[0] - radius <= u1 && r[2] + radius >= u0 && r[1] - radius <= v1 && r[3] + radius >= v0);
+    const tooClose = (u, v) => bodies.some((r) => {
+      const dx = Math.max(r[0] - u, 0, u - r[2]);
+      const dz = Math.max(r[1] - v, 0, v - r[3]);
+      return dx * dx + dz * dz < radius * radius - 1e-9;
+    });
+    for (let j = 0; j < nz; j++)
+      for (let i = 0; i < nx; i++) {
+        const u = u0 + (i + 0.5) * gs;
+        const v = v0 + (j + 0.5) * gs;
+        if (insets.some((r) => u >= r[0] && u <= r[2] && v >= r[1] && v <= r[3]) && (room.outdoor || !tooClose(u, v))) insideCells[j * nx + i] = 1;
+      }
+    const entries = [];
+    for (const ab of openingsOfFloor(plan, room.floor))
+      if (!(ignored && ignored.has(ab.id)))
+        for (const pt of entryPoints(ab)) {
+          if (!inRect(room, pt[0], pt[1])) continue;
+          const i = Math.floor((pt[0] - u0) / gs);
+          const j = Math.floor((pt[1] - v0) / gs);
+          if (i >= 0 && j >= 0 && i < nx && j < nz && insideCells[j * nx + i]) entries.push([i, j]);
+        }
+    if (!room.outdoor)
+      for (const pair of plan.openPairs[room.floor] || []) {
+        const otherId = pair[0] === room.id ? pair[1] : pair[1] === room.id ? pair[0] : null;
+        const other = otherId && plan.rooms.find((c) => c.id === otherId && c.floor === room.floor);
+        if (!other) continue;
+        const edge = sharedEdge(room, other, null);
+        if (!edge || edge.a1 - edge.a0 > 2) continue;
+        const mid = (edge.a0 + edge.a1) / 2;
+        for (const offset of [-0.4, 0.4]) {
+          const pt = edge.axis === "u" ? [mid, edge.pos + offset] : [edge.pos + offset, mid];
+          if (!inRect(room, pt[0], pt[1])) continue;
+          const i = Math.floor((pt[0] - u0) / gs);
+          const j = Math.floor((pt[1] - v0) / gs);
+          if (i >= 0 && j >= 0 && i < nx && j < nz && insideCells[j * nx + i]) entries.push([i, j]);
+        }
+      }
+    const R = inner(room.parts[0]);
+    return { gs, u0, v0, nx, nz, inside: insideCells, entries, center: [(R[0] + R[2]) / 2, (R[1] + R[3]) / 2] };
+  }
+  function reachable(g, solids, inflation) {
+    const { gs, u0, v0, nx, nz, inside } = g;
+    const blocked = new Uint8Array(nx * nz);
+    for (const r of solids) {
+      const i0 = Math.max(0, Math.floor((r[0] - inflation - u0) / gs));
+      const i1 = Math.min(nx - 1, Math.floor((r[2] + inflation - u0) / gs));
+      const j0 = Math.max(0, Math.floor((r[1] - inflation - v0) / gs));
+      const j1 = Math.min(nz - 1, Math.floor((r[3] + inflation - v0) / gs));
+      for (let j = j0; j <= j1; j++)
+        for (let i = i0; i <= i1; i++) {
+          const u = u0 + (i + 0.5) * gs;
+          const v = v0 + (j + 0.5) * gs;
+          if (u > r[0] - inflation && u < r[2] + inflation && v > r[1] - inflation && v < r[3] + inflation) blocked[j * nx + i] = 1;
+        }
+    }
+    let best = -1;
+    let bestDist = 1e9;
+    for (let j = 0; j < nz; j++)
+      for (let i = 0; i < nx; i++) {
+        const k = j * nx + i;
+        if (!inside[k] || blocked[k]) continue;
+        const dist = Math.hypot(u0 + (i + 0.5) * gs - g.center[0], v0 + (j + 0.5) * gs - g.center[1]);
+        if (dist < bestDist) {
+          bestDist = dist;
+          best = k;
+        }
+      }
+    if (best < 0) return false;
+    if (!g.entries.length) return true;
+    for (const [i, j] of g.entries) if (blocked[j * nx + i]) return false;
+    const visited = new Uint8Array(nx * nz);
+    const queue = new Int32Array(nx * nz);
+    let h = 0;
+    let t = 0;
+    const s = g.entries[0][1] * nx + g.entries[0][0];
+    visited[s] = 1;
+    queue[t++] = s;
+    while (h < t) {
+      const k = queue[h++];
+      const i = k % nx;
+      const j = (k - i) / nx;
+      for (const [di, dj] of [[1, 0], [-1, 0], [0, 1], [0, -1]]) {
+        const a = i + di;
+        const b = j + dj;
+        if (a < 0 || b < 0 || a >= nx || b >= nz) continue;
+        const q = b * nx + a;
+        if (visited[q] || !inside[q] || blocked[q]) continue;
+        visited[q] = 1;
+        queue[t++] = q;
+      }
+    }
+    if (!visited[best]) return false;
+    for (const [i, j] of g.entries) if (!visited[j * nx + i]) return false;
+    return true;
+  }
+  function candidatesOf(cats) {
+    const out = [];
+    for (const [cat, weight] of Object.entries(cats)) {
+      const exact = cat[0] === "=";
+      const its = Object.values(registries().CATALOG).filter((i) => !i.decor && (exact ? i.type === cat.slice(1) : !i.exactOnly && (i.category === cat || i.type === cat)));
+      for (const it of its) out.push({ it, weight: weight / its.length });
+    }
+    return out;
+  }
+  function itemRect(slot, it, shift) {
+    const c = slot._cell;
+    if (!c) throw new Error("Slot without a cell: " + slot.id);
+    const f = c.f;
+    const [extentU, extentV] = extent([it.w, it.d], f);
+    const R = c.R;
+    let u0 = (c.rect ? (c.rect[0] + c.rect[2]) / 2 : slot.x) - extentU / 2;
+    let v0 = (c.rect ? (c.rect[1] + c.rect[3]) / 2 : slot.z) - extentV / 2;
+    if (shift) {
+      if (slot.side === "left" || slot.side === "right") v0 += shift;
+      else u0 += shift;
+    }
+    for (const s of c.enclosed) {
+      if (s === "left") u0 = R[0];
+      else if (s === "right") u0 = R[2] - extentU;
+      else if (s === "front") v0 = R[1];
+      else if (s === "back") v0 = R[3] - extentV;
+    }
+    return [u0, v0, u0 + extentU, v0 + extentV];
+  }
+  var RELAXED_RADIUS = 0.12;
+  var MESH_FRONT = { "+z": [0, 1], "-z": [0, -1], "+x": [1, 0], "-x": [-1, 0] };
+  function rotationFor(f, front) {
+    const meshFront = MESH_FRONT[front] || [0, 1];
+    let ry = Math.atan2(f[0], f[1]) - Math.atan2(meshFront[0], meshFront[1]);
+    if (ry > Math.PI + EPS) ry -= 2 * Math.PI;
+    if (ry < -Math.PI - EPS) ry += 2 * Math.PI;
+    return r2(ry);
+  }
+  function fillRoom(plan, room, slots2, rng) {
+    const items = [];
+    const missing = [];
+    const state = {};
+    const solids = [];
+    const reserves = [];
+    const rims = [];
+    const inners = usableParts(room, 0);
+    const grid = createGrid(plan, room);
+    const relaxedGrid = room.outdoor ? grid : createGrid(plan, room, null, RELAXED_RADIUS);
+    const zones = zonesOfFloor(plan, room.floor);
+    const windowZones = windowsOfRoom(plan, room).map((j) => ({ z: windowZone(j, room.outdoor), j }));
+    const inflation = room.outdoor ? 0.15 : plan.playerRadius;
+    const units = [];
+    const seen = {};
+    for (const s of slots2) {
+      if (s.group) {
+        if (seen[s.group]) {
+          seen[s.group].members.push(s);
+          continue;
+        }
+        const u = { group: s.group, members: [s] };
+        seen[s.group] = u;
+        units.push(u);
+      } else units.push({ group: null, members: [s] });
+    }
+    for (const u of units) u.required = u.members.some((m) => m.required);
+    const queue = units.filter((u) => u.required).concat(units.filter((u) => !u.required));
+    const dependencies = (u) => u.members.flatMap((m) => [m.requires, m.on]).filter(Boolean).filter((id) => slots2.some((s) => s.id === id && !u.members.includes(s)));
+    const done = /* @__PURE__ */ new Set();
+    const ready = (u) => dependencies(u).every((id) => done.has(id));
+    const make = (s, it, r, parent, overheadOff) => {
+      const f = [s.frontU, s.frontV];
+      const id = room.id + "." + s.id;
+      const m = {
+        id,
+        type: it.type,
+        category: it.category,
+        x: r2((r[0] + r[2]) / 2),
+        z: r2((r[1] + r[3]) / 2),
+        ry: rotationFor(f, it.front),
+        w: it.w,
+        d: it.d,
+        h: it.h,
+        y: parent ? r2((parent.y || 0) + parent.h) : 0,
+        frontU: f[0],
+        frontV: f[1],
+        room: room.id,
+        floor: room.floor,
+        outdoor: !!room.outdoor,
+        slot: s.id,
+        on: parent ? s.on : null,
+        mode: parent ? s.anchor === "inside" ? "inside" : "on" : null,
+        clearance: s.clearance,
+        flat: it.flat,
+        low: it.low,
+        aabb: r.map(r2),
+        _r: r,
+        _seedId: registries().SEED_KEYS.items[id] ?? id
+      };
+      if (it.overhead) m.overhead = !overheadOff;
+      if (it.category === "car") {
+        m.driver = [f[1], -f[0]];
+        m.carClearance = plan.carClearance;
+      }
+      if (parent && s.anchor === "inside") m.y = r2(parent.y || 0);
+      if (room.link) m.link = { from: room.link[0], to: room.link[1] };
+      state[s.id] = m;
+      items.push(m);
+      return m;
+    };
+    const tryFit = (s, relax, overheadOff) => {
+      const cands = weightedOrder(candidatesOf(s.cats), rng);
+      if (s.anchor === "on" || s.anchor === "inside") {
+        const parent = state[s.on];
+        if (!parent) return null;
+        for (const { it } of cands) {
+          if (it.w > parent.w + EPS || it.d > parent.d + EPS) continue;
+          const f = [parent.frontU ?? 0, parent.frontV ?? 1];
+          const r = parent.aabb;
+          const [extentU, extentV] = extent([it.w, it.d], f);
+          const cu = (r[0] + r[2]) / 2 - f[0] * (parent.d / 2 - it.d / 2);
+          const cv = (r[1] + r[3]) / 2 - f[1] * (parent.d / 2 - it.d / 2);
+          return make(s, it, [cu - extentU / 2, cv - extentV / 2, cu + extentU / 2, cv + extentV / 2], parent);
+        }
+        return null;
+      }
+      for (const { it } of cands) {
+        if (it.w > s.w + EPS || it.d > s.d + EPS) continue;
+        const f = [s.frontU, s.frontV];
+        const slide = s.anchor === "wall" ? s.slide == null ? 2 : s.slide : 0;
+        const shifts = [0];
+        for (let k = 1; k * 0.1 <= slide + 1e-9; k++) shifts.push(k * 0.1, -k * 0.1);
+        let found = null;
+        const car = it.category === "car" && !relax;
+        const tries = car ? carCandidates(s, it, plan.carClearance) : shifts.map((shift) => ({ rect: itemRect(s, it, shift) }));
+        for (const attempt of tries) {
+          const r3 = attempt.rect;
+          if (!insideUnion(r3, inners)) continue;
+          if (car && (!insideUnion(attempt.clear, inners) || solids.some((o) => overlaps(attempt.clear, o)))) continue;
+          if (it.flat) {
+            found = { rect: r3 };
+            break;
+          }
+          if (zones.some((z) => overlaps(r3, z))) continue;
+          if (windowZones.some(({ z, j }) => blocksWindow(it, j, overheadOff) && overlaps(r3, z))) continue;
+          if (solids.some((o) => overlaps(r3, o))) continue;
+          if (!it.deck && rims.some((a) => overlaps(r3, a))) continue;
+          let cl2 = car ? attempt.clear : null;
+          if (!car && !relax && s.clearance > 0 && !it.low) {
+            cl2 = clearRect(r3, f, s.clearance);
+            if (!insideUnion(cl2, inners)) continue;
+            if (items.some((m2) => !m2.low && !m2.flat && !m2.on && overlaps(cl2, m2._r ?? m2.aabb))) continue;
+          }
+          if (!it.low && reserves.some((q) => overlaps(r3, q))) continue;
+          let rimRect2 = null;
+          if (it.rim) {
+            rimRect2 = [r3[0] - it.rim, r3[1] - it.rim, r3[2] + it.rim, r3[3] + it.rim];
+            if (!insideUnion(rimRect2, inners) || solids.some((o) => overlaps(rimRect2, o)) || zones.some((z) => overlaps(rimRect2, z))) continue;
+          }
+          if (!(relax ? reachable(relaxedGrid, solids.concat([r3]), RELAXED_RADIUS) : reachable(grid, solids.concat([r3]), inflation))) continue;
+          found = { rect: r3, cl: cl2, rimRect: rimRect2 };
+          break;
+        }
+        if (!found) continue;
+        const { rect: r, cl, rimRect } = found;
+        if (it.flat) return make(s, it, r, null);
+        const m = make(s, it, r, null, overheadOff);
+        if (cl) reserves.push(cl);
+        if (rimRect) rims.push(rimRect);
+        solids.push(r);
+        return m;
+      }
+      return null;
+    };
+    const process2 = (u) => {
+      const pr = u.members[0].chance;
+      const x = rng();
+      const arr = u.members.slice();
+      const members = [];
+      while (arr.length) members.push(arr.splice(arr.length > 1 ? Math.floor(rng() * arr.length) : 0, 1)[0]);
+      const applicable = members.filter((m) => m.valid && (!m.requires || state[m.requires]) && (!m.on || state[m.on]));
+      if (!u.required && x >= pr) return;
+      let ok = false;
+      for (const m of applicable) {
+        if (tryFit(m, false)) {
+          ok = true;
+          break;
+        }
+      }
+      if (!ok)
+        for (const m of applicable) {
+          if (tryFit(m, false, true)) {
+            ok = true;
+            break;
+          }
+        }
+      if (!ok && u.required)
+        for (const m of applicable) {
+          if (tryFit(m, true, true)) {
+            ok = true;
+            break;
+          }
+        }
+      if (!ok && u.required && (applicable.length || !u.members.some((m) => m.requires))) missing.push({ room: room.id, slot: u.group || u.members[0].id });
+    };
+    const pending = queue.slice();
+    while (pending.length) {
+      let i = pending.findIndex(ready);
+      if (i < 0) i = 0;
+      const u = pending.splice(i, 1)[0];
+      process2(u);
+      for (const m of u.members) done.add(m.id);
+    }
+    return { items, missing };
+  }
+  var STREAM = {
+    facade: "fachada",
+    lot: "lote",
+    decor: "decor",
+    roomPrefix: "c:",
+    palettePrefix: "paleta:"
+  };
+  var placementKit = {
+    MARGIN,
+    EPS,
+    r2,
+    clamp,
+    overlaps,
+    inner,
+    inflate,
+    areaOf,
+    topOf,
+    extent,
+    insideUnion,
+    usableParts,
+    zonesOfFloor,
+    windowsOfRoom,
+    windowZone,
+    roomAt,
+    reachable,
+    createGrid,
+    clearRect,
+    pickWeighted,
+    createRng,
+    roomSeedKey: (room) => room.seedKey ?? registries().SEED_KEYS.rooms[room.id] ?? room.id,
+    shuffle,
+    facingRotation: (f, type) => rotationFor(f, registries().CATALOG[type].front),
+    cutIntervals,
+    blocksWindow
+  };
+  function createPlacementContext(plan, items) {
+    const added = [];
+    const counters = {};
+    const make = (room, type, r, f, o) => {
+      const it = registries().CATALOG[type];
+      const n = counters[room.id + type] = (counters[room.id + type] || 0) + 1;
+      return Object.assign(
+        {
+          id: room.id + ".dec_" + type + n,
+          type,
+          category: it.category,
+          x: r2((r[0] + r[2]) / 2),
+          z: r2((r[1] + r[3]) / 2),
+          ry: r2(Math.atan2(f[0], f[1])),
+          w: it.w,
+          d: it.d,
+          h: it.h,
+          y: 0,
+          frontU: f[0],
+          frontV: f[1],
+          room: room.id,
+          floor: room.floor,
+          outdoor: !!room.outdoor,
+          slot: "dec_" + type + n,
+          on: null,
+          mode: null,
+          clearance: 0,
+          flat: !!it.flat,
+          low: it.low,
+          aabb: r.map(r2),
+          _r: r,
+          decor: true,
+          mount: it.mount
+        },
+        o || {}
+      );
+    };
+    const add = (m) => {
+      added.push(m);
+      items.push(m);
+      return m;
+    };
+    const itemsOfRoom = (c) => items.filter((m) => m.room === c.id && m.floor === c.floor);
+    const extraSolids = {};
+    const solidsOfRoom = (c) => itemsOfRoom(c).filter((m) => !m.flat && !m.on && (!m.decor || m.mount === "floor")).map((m) => m._r).concat(extraSolids[c.id] || []);
+    const gridCache = {};
+    let ignored = null;
+    const gridOf = (c) => gridCache[c.id] || (gridCache[c.id] = createGrid(plan, c, ignored));
+    function placeOnFloor(room, type, rng2, optsIn) {
+      const opts = Object.assign({}, optsIn || {});
+      const it0 = registries().CATALOG[type];
+      if (it0.flat) opts.flat = true;
+      const it = registries().CATALOG[type];
+      const inners = usableParts(room, 0);
+      const solidList = solidsOfRoom(room);
+      const zones = zonesOfFloor(plan, room.floor);
+      const occupied = itemsOfRoom(room);
+      const windowZones = windowsOfRoom(plan, room).map((j) => ({ z: windowZone(j, room.outdoor), j }));
+      const landings = it0.flat ? [] : items.filter((m) => m.type === "stairs" && m.floor === room.floor && m.aabb).map((m) => {
+        const r = m.aabb;
+        return m.frontV === 1 ? [r[0], r[3], r[2], r[3] + 1] : m.frontV === -1 ? [r[0], r[1] - 1, r[2], r[1]] : m.frontU === 1 ? [r[2], r[1], r[2] + 1, r[3]] : [r[0] - 1, r[1], r[0], r[3]];
+      });
+      const cand = opts.cands ? opts.cands.slice() : [];
+      if (!opts.cands)
+        for (const p of inners) {
+          const extentU = opts.dim ? opts.dim[0] : it.w;
+          const extentV = opts.dim ? opts.dim[1] : it.d;
+          for (const [x, z] of [[p[0], p[1]], [p[2] - extentU, p[1]], [p[0], p[3] - extentV], [p[2] - extentU, p[3] - extentV]]) cand.push([x, z, x + extentU, z + extentV]);
+          for (let k = 0; k < 6; k++) {
+            const t = rng2();
+            const side = Math.floor(rng2() * 4);
+            const x = side < 2 ? p[0] + t * Math.max(0, p[2] - p[0] - extentU) : side === 2 ? p[0] : p[2] - extentU;
+            const z = side >= 2 ? p[1] + t * Math.max(0, p[3] - p[1] - extentV) : side === 0 ? p[1] : p[3] - extentV;
+            cand.push([x, z, x + extentU, z + extentV]);
+          }
+        }
+      for (const r of opts.ordered ? cand : shuffle(cand, rng2)) {
+        if (!insideUnion(r, inners)) continue;
+        if (zones.some((z) => overlaps(r, z)) || landings.some((z) => overlaps(r, z))) continue;
+        if (windowZones.some(({ z, j }) => blocksWindow(it, j) && overlaps(r, z))) continue;
+        if (solidList.some((o) => overlaps(r, o))) continue;
+        if (opts.flat) {
+          if (!(opts.without && opts.without(r))) return r;
+          continue;
+        }
+        if (occupied.some((m) => !m.low && !m.flat && !m.on && !m.decor && (m.clearance ?? 0) > 0 && overlaps(r, clearRect(m._r, [m.frontU ?? 0, m.frontV ?? 1], m.clearance ?? 0)))) continue;
+        if (opts.without && opts.without(r)) continue;
+        if (!reachable(opts.railing || gridOf(room), solidList.concat([r]), room.outdoor ? 0.16 : plan.playerRadius)) continue;
+        return r;
+      }
+      return null;
+    }
+    const roomById = (id) => plan.rooms.find((c) => c.id === id) || plan.zones.find((c) => c.id === id);
+    return {
+      make,
+      add,
+      placeOnFloor,
+      itemsOfRoom,
+      solidsOfRoom,
+      gridOf,
+      extraSolids,
+      roomById,
+      setIgnored: (s) => {
+        ignored = s;
+        for (const k of Object.keys(gridCache)) delete gridCache[k];
+      },
+      added
+    };
+  }
+  function groundCover(plan, items, ctx) {
+    if (!plan.lot) return;
+    const polygonOf = (r) => [[r[0], r[1]], [r[2], r[1]], [r[2], r[3]], [r[0], r[3]]].map((p) => [r2(p[0]), r2(p[1])]);
+    const groundPiece = (z, type, r, layer, i) => {
+      const m = ctx.make(z, type, r, [0, 1], {
+        id: z.id + ".ground" + (layer ? "_overlay" : "") + i,
+        slot: "ground" + (layer ? "_overlay" : "") + i,
+        w: r2(r[2] - r[0]),
+        d: r2(r[3] - r[1]),
+        h: 0,
+        polygon: polygonOf(r),
+        layer,
+        zone: z.id,
+        outdoor: true,
+        floor: -1
+      });
+      return ctx.add(m);
+    };
+    for (const z of plan.zones) {
+      z.parts.forEach((p, i) => groundPiece(z, z.ground, p, 0, i));
+      let k = 0;
+      const clip = (r) => z.parts.map((p) => [Math.max(r[0], p[0]), Math.max(r[1], p[1]), Math.min(r[2], p[2]), Math.min(r[3], p[3])]).filter((q) => q[2] - q[0] > 0.3 && q[3] - q[1] > 0.3).sort((a, b) => areaOf(b) - areaOf(a))[0];
+      for (const rule of registries().GROUND_OVERLAYS) {
+        const triggers = items.filter((m) => m.room === z.id && m.category === rule.category);
+        if (rule.merge) {
+          if (triggers.length && z.ground !== rule.unlessGround) {
+            const u = triggers.reduce((a, m) => [Math.min(a[0], m._r[0]), Math.min(a[1], m._r[1]), Math.max(a[2], m._r[2]), Math.max(a[3], m._r[3])], [1e9, 1e9, -1e9, -1e9]);
+            const q = clip(inflate(u, rule.inflate));
+            if (q) groundPiece(z, rule.ground, q, 1, k++);
+          }
+        } else {
+          for (const m of triggers) {
+            const q = clip(inflate(m._r, rule.inflate));
+            if (q) groundPiece(z, rule.ground, q, 1, k++);
+          }
+        }
+      }
+    }
+  }
+  function runPostProcess(plan, items, seed) {
+    const ctx = createPlacementContext(plan, items);
+    const rng = createRng(seed, STREAM.decor);
+    for (const pass of registries().PASSES) pass.run({ plan, items, seed, rng, ctx, kit: placementKit, catalog: registries().CATALOG, profiles: registries().DECOR_PROFILES });
+    groundCover(plan, items, ctx);
+    return ctx;
+  }
   function registerLocale(code, table) {
+    const { LOCALES: locales } = registries();
     const cur = locales[code] = locales[code] || {};
     for (const ns of Object.keys(table)) cur[ns] = Object.assign(cur[ns] || {}, table[ns]);
   }
-  var PERMEABLE_GROUNDS = /* @__PURE__ */ new Set();
+  var listLocales = () => Object.keys(registries().LOCALES);
+  function translate(ns, key, locale = "en", vars) {
+    const { LOCALES: locales } = registries();
+    const raw = locales[locale]?.[ns]?.[key] ?? locales.en?.[ns]?.[key] ?? key;
+    return vars ? raw.replace(/\{(\w+)\}/g, (m, k) => k in vars ? String(vars[k]) : m) : raw;
+  }
+  var CLOSE = 1e-6;
+  var rounded = (r) => r.map(r2);
+  var touches = (a, r) => a[0] <= r[2] + CLOSE && a[2] >= r[0] - CLOSE && a[1] <= r[3] + CLOSE && a[3] >= r[1] - CLOSE;
+  function addExteriorDoorPaths(plan, c) {
+    const { gates, paths, zones, setback, marginLeft, marginRight, backyard, w } = c;
+    const social = gates.find((g) => g.type === "pedestrian");
+    const socialPath = social ? paths.find((p) => p.from === social.id && p.type === "pedestrian") : null;
+    const parkingZone = zones.find((z) => z.id === "parking");
+    const parking = parkingZone ? parkingZone.parts[0] : null;
+    const midY = setback > 0 ? -setback / 2 : 0;
+    const joinToSocial = (x, width, rects, points) => {
+      if (!socialPath) return;
+      const h = width / 2;
+      const horizontal = socialPath.rects.find((r) => midY >= r[1] - CLOSE && midY <= r[3] + CLOSE && r[2] - r[0] > r[3] - r[1]) || socialPath.rects[0];
+      const targetX = x < horizontal[0] ? horizontal[0] + h : x > horizontal[2] ? horizontal[2] - h : x;
+      if (Math.abs(targetX - x) > CLOSE) {
+        rects.push([Math.min(x, targetX) - h, midY - h, Math.max(x, targetX) + h, midY + h]);
+        points.push([targetX, midY]);
+      }
+    };
+    for (const door of plan.doors.filter((q) => q.floor === 0 && q.exterior)) {
+      if (paths.some((p) => p.to === door.id)) continue;
+      const half = Math.max(1, Math.min(door.width, 2)) / 2;
+      const rects = [];
+      const points = [];
+      const isTarget = c.target && door.a === c.target.a && door.side === c.target.side;
+      let fromId = social ? social.id : null;
+      let width = 1;
+      const id = isTarget ? "entrance_path" : "path_" + door.id;
+      if (door.side === "front") {
+        if (setback > 0) {
+          const stub = Math.min(1, setback);
+          rects.push([door.u - half, -stub, door.u + half, 0]);
+          points.push([door.u, 0], [door.u, -stub]);
+          if (-stub > midY) {
+            rects.push([door.u - width / 2, midY - width / 2, door.u + width / 2, -stub]);
+            points.push([door.u, midY]);
+          }
+          joinToSocial(door.u, width, rects, points);
+        } else {
+          rects.push([door.u - half, -1.2, door.u + half, 0]);
+          points.push([door.u, 0], [door.u, -1.2]);
+        }
+      } else {
+        const lanes = [];
+        if (marginLeft > 0.5) lanes.push({ x: -marginLeft / 2, width: marginLeft, side: "left" });
+        if (marginRight > 0.5) lanes.push({ x: w + marginRight / 2, width: marginRight, side: "right" });
+        const targets = paths.flatMap((p) => p.rects).concat(parking ? [parking] : []);
+        let best = null;
+        for (const lane of lanes) {
+          if (door.side === "left" && lane.side !== "left" || door.side === "right" && lane.side !== "right") continue;
+          const laneWidth = Math.min(0.9, lane.width - 0.1);
+          const h = laneWidth / 2;
+          const rearStrip = Math.min(0.8, backyard);
+          const rearY = door.v + rearStrip + laneWidth / 2;
+          const overlapsParking = !!parking && lane.x + h > parking[0] && lane.x - h < parking[2];
+          const frontY = overlapsParking || setback <= 0 ? 0 : -0.6;
+          let frontStub = null;
+          if (!overlapsParking && setback > 0) {
+            const dir = social && social.u < lane.x ? -1 : 1;
+            const band = [-0.6 - h, -0.6 + h];
+            let nearestX = social ? social.u : lane.x;
+            let nearestGap = Infinity;
+            for (const r of targets) {
+              if (!(r[1] <= band[1] && r[3] >= band[0])) continue;
+              const edge = dir < 0 ? r[2] : r[0];
+              const gap = Math.abs(edge - lane.x);
+              if ((dir < 0 ? edge <= lane.x : edge >= lane.x) && gap < nearestGap) {
+                nearestGap = gap;
+                nearestX = edge;
+              }
+            }
+            frontStub = [Math.min(lane.x, nearestX) - (dir < 0 ? 0 : h), -0.6 - h, Math.max(lane.x, nearestX) + (dir < 0 ? h : 0), -0.6 + h];
+          }
+          const vertical = [lane.x - h, frontY - (frontY < 0 ? h : 0), lane.x + h, (door.side === "back" ? rearY : door.v) + laneWidth / 2];
+          const horizontal = door.side === "back" ? [Math.min(door.u, lane.x) - half, rearY - laneWidth / 2, Math.max(door.u, lane.x) + h, rearY + laneWidth / 2] : null;
+          const cost = (horizontal ? horizontal[2] - horizontal[0] : 0) + (frontStub ? frontStub[2] - frontStub[0] : 0);
+          if (!best || cost < best.cost) best = { lane, laneWidth, half: h, vertical, horizontal, frontStub, cost, rearStrip, rearY, frontY, overlapsParking };
+        }
+        if (best) {
+          const { lane, laneWidth, half: h, vertical, horizontal, frontStub, rearStrip, rearY, frontY, overlapsParking } = best;
+          width = laneWidth;
+          if (overlapsParking) fromId = (gates.find((g) => g.type === "garage") || social || {}).id || null;
+          if (door.side === "back") {
+            rects.push([door.u - half, door.v, door.u + half, door.v + rearStrip + laneWidth], horizontal, vertical);
+            points.push([door.u, door.v], [door.u, rearY], [lane.x, rearY], [lane.x, frontY]);
+          } else {
+            const x0 = door.side === "left" ? lane.x - h : w;
+            const x1 = door.side === "left" ? 0 : lane.x + h;
+            rects.push([Math.min(x0, x1), door.v - half, Math.max(x0, x1), door.v + half], vertical);
+            points.push([door.u, door.v], [lane.x, door.v], [lane.x, frontY]);
+          }
+          if (frontStub) {
+            rects.push(frontStub);
+            points.push([frontStub[0] < lane.x ? frontStub[0] : frontStub[2], -0.6]);
+          }
+        } else {
+          const stub = 1;
+          if (door.side === "back") rects.push([door.u - half, door.v, door.u + half, door.v + Math.min(stub, backyard)]);
+          else rects.push(door.side === "left" ? [-Math.min(stub, marginLeft), door.v - half, 0, door.v + half] : [w, door.v - half, w + Math.min(stub, marginRight), door.v + half]);
+          points.push([door.u, door.v]);
+        }
+      }
+      const reached = rects.slice();
+      const pool = paths.flatMap((p) => p.rects).concat(parking ? [parking] : []);
+      let grows = true;
+      while (grows) {
+        grows = false;
+        for (const r of pool) {
+          if (!reached.includes(r) && reached.some((a) => touches(a, r))) {
+            reached.push(r);
+            grows = true;
+          }
+        }
+      }
+      const inside = (g) => reached.some((r) => g.u >= r[0] - CLOSE && g.u <= r[2] + CLOSE && g.v >= r[1] - CLOSE && g.v <= r[3] + CLOSE);
+      const gate = gates.find((q) => q.type === "pedestrian" && inside(q)) || gates.find((q) => q.type !== "cargo" && inside(q));
+      if (gate) fromId = gate.id;
+      paths.push({ id, type: "pedestrian", from: fromId, to: door.id, width, rects: rects.map(rounded), points: points.map((q) => q.map(r2)) });
+    }
+  }
+  function defineZone(zone) {
+    if (!zone || !zone.id) throw new Error("defineZone: id is required");
+    registries().ZONES[zone.id] = zone;
+    return zone;
+  }
+  var getZone = (id) => registries().ZONES[id];
+  var listZones = () => Object.values(registries().ZONES);
   function registerPermeableGround(...types) {
-    for (const t of types) PERMEABLE_GROUNDS.add(t);
+    for (const t of types) registries().PERMEABLE_GROUNDS.add(t);
+  }
+  function resolveZone(z) {
+    if (!z) return null;
+    if (typeof z === "string") {
+      const found = registries().ZONES[z];
+      if (!found) throw new Error("Unknown zone: " + z);
+      return found;
+    }
+    return z;
+  }
+  var floorsOfTemplate = (tpl, op) => (tpl.floorsFn ? tpl.floorsFn(op) : tpl.floors || []).length;
+  var useOf = (tpl) => tpl.use || "residential_single";
+  function measure(plan) {
+    const floors = plan.floors;
+    const top = floors.reduce((m, f) => Math.max(m, f.y0 + f.ceiling), 0);
+    const number = plan.floorNumber != null ? plan.floorNumber : floors.length;
+    const rooms = (plan.rooms || []).filter((r) => r.floor >= 0);
+    const area = (r) => r.parts.reduce((s, p) => s + (p[2] - p[0]) * (p[3] - p[1]), 0);
+    const footprint = plan.w * plan.d;
+    const built = rooms.reduce((s, r) => s + area(r), 0);
+    return { storeys: number, height: r2(top), footprint, built };
+  }
+  function checkLot(zoneIn, lot, plan) {
+    const zone = resolveZone(zoneIn);
+    const out = [];
+    const m = measure(plan);
+    const use = plan.use || "residential_single";
+    if (!zone.allowedUses.includes(use)) out.push({ rule: "use", actual: use, limit: zone.allowedUses.join(",") });
+    if (m.storeys > zone.maxFloors) out.push({ rule: "floors", actual: m.storeys, limit: zone.maxFloors });
+    if (m.height > zone.maxHeight + 1e-9) out.push({ rule: "height", actual: m.height, limit: zone.maxHeight });
+    if (!lot) return out;
+    const [u0, v0, u1, v1] = lot.rect;
+    const width = r2(u1 - u0);
+    const depth = r2(v1 - v0);
+    const area = width * depth;
+    const party = plan.partyWalls || [];
+    const sides = [party.includes("left") ? Infinity : lot.sideYard.left, party.includes("right") ? Infinity : lot.sideYard.right];
+    const left = sides[0];
+    const right = sides[1];
+    if (lot.setback < zone.setbacks.front - 1e-9) out.push({ rule: "setback_front", actual: lot.setback, limit: zone.setbacks.front });
+    if (Math.min(left, right) < zone.setbacks.side - 1e-9) out.push({ rule: "setback_side", actual: Math.min(left, right), limit: zone.setbacks.side });
+    if (lot.backyard < zone.setbacks.back - 1e-9) out.push({ rule: "setback_back", actual: lot.backyard, limit: zone.setbacks.back });
+    if (area < zone.minLot - 1e-9) out.push({ rule: "min_lot", actual: r2(area), limit: zone.minLot });
+    if (width < zone.minFrontage - 1e-9) out.push({ rule: "min_frontage", actual: width, limit: zone.minFrontage });
+    const ground = m.footprint;
+    const coverage = ground / area;
+    if (coverage > zone.maxCoverage + 1e-9) out.push({ rule: "coverage", actual: r2(coverage), limit: zone.maxCoverage });
+    const far = m.built / area;
+    if (far > zone.maxFar + 1e-9) out.push({ rule: "far", actual: r2(far), limit: zone.maxFar });
+    let permeable = 0;
+    for (const z of lot.zones) if (z.ground && registries().PERMEABLE_GROUNDS.has(z.ground)) for (const p of z.parts) permeable += (p[2] - p[0]) * (p[3] - p[1]);
+    const permeability = permeable / area;
+    if (permeability < zone.permeableMin - 1e-9) out.push({ rule: "permeable", actual: r2(permeability), limit: zone.permeableMin });
+    return out;
+  }
+  function clampOptionsToZone(tpl, op, zone, adjustments) {
+    if (tpl.singleFloor) {
+      const ceiling2 = (tpl.floors || tpl.floorsFn?.(op) || [])[0]?.ceiling ?? 2.8;
+      const current2 = op.floor || 3;
+      const limit2 = Math.max(1, Math.min(zone.maxFloors, Math.floor(zone.maxHeight / ceiling2 + 1e-9)));
+      if (current2 <= limit2) return op;
+      adjustments.push({ field: "floor", from: current2, to: limit2, reason: current2 > zone.maxFloors ? "max_floors" : "max_height" });
+      return Object.assign({}, op, { floor: limit2 });
+    }
+    if (!tpl.floorRange || !tpl.floorsFn) return op;
+    const current = floorsOfTemplate(tpl, op);
+    const floors = tpl.floorsFn(op);
+    const ceiling = floors.reduce((m, f) => Math.max(m, f.ceiling), 0) || 2.8;
+    const byHeight = Math.max(1, Math.floor(zone.maxHeight / ceiling + 1e-9));
+    const limit = Math.max(tpl.floorRange[0], Math.min(zone.maxFloors, byHeight, tpl.floorRange[1]));
+    if (current <= limit) return op;
+    adjustments.push({ field: "floors", from: current, to: limit, reason: current > zone.maxFloors ? "max_floors" : "max_height" });
+    return Object.assign({}, op, { floors: limit });
+  }
+  function clampLotToZone(cfg, zone, adjustments, partyWalls = []) {
+    const raise = (field, key, min, reason) => {
+      if (cfg[key] < min) {
+        adjustments.push({ field, from: cfg[key], to: min, reason });
+        cfg[key] = min;
+      }
+    };
+    raise("frontSetback", "frontSetback", zone.setbacks.front, "setback_front");
+    if (!partyWalls.includes("left")) raise("marginLeft", "marginLeft", zone.setbacks.side, "setback_side");
+    if (!partyWalls.includes("right")) raise("marginRight", "marginRight", zone.setbacks.side, "setback_side");
+    raise("backyardDepth", "backyardDepth", zone.setbacks.back, "setback_back");
+  }
+  var ADJUSTABLE_ZONES = /* @__PURE__ */ new Set(["garden", "backyard", "side_yard"]);
+  function enforcePermeability(lot, zones, zone, adjustments) {
+    const target = [...registries().PERMEABLE_GROUNDS][0];
+    if (!target) return;
+    const [u0, v0, u1, v1] = lot.rect;
+    const area = (u1 - u0) * (v1 - v0);
+    const areaOfZone = (z) => z.parts.reduce((s, p) => s + (p[2] - p[0]) * (p[3] - p[1]), 0);
+    let permeable = zones.filter((z) => z.ground != null && registries().PERMEABLE_GROUNDS.has(z.ground)).reduce((s, z) => s + areaOfZone(z), 0);
+    if (permeable / area >= zone.permeableMin) return;
+    const candidates = zones.filter((z) => ADJUSTABLE_ZONES.has(z.type) && !(z.ground != null && registries().PERMEABLE_GROUNDS.has(z.ground))).sort((a, b) => areaOfZone(b) - areaOfZone(a));
+    for (const z of candidates) {
+      if (permeable / area >= zone.permeableMin) break;
+      adjustments.push({ field: "ground:" + z.id, from: z.ground ?? "", to: target, reason: "permeable_min" });
+      z.ground = target;
+      permeable += areaOfZone(z);
+    }
+  }
+  var floorsOf = (tpl, op) => tpl.floorsFn ? tpl.floorsFn(op || {}) : tpl.floors;
+  function clampSize(tpl, w, d, op) {
+    const L = tpl.limitsFn ? tpl.limitsFn(op || {}) : tpl.limits;
+    const P0 = tpl.defaultsFn ? tpl.defaultsFn(op || {}) : tpl.defaults;
+    const ww = w == null ? P0.w : clamp(w, L.w[0], L.w[1]);
+    const dd = d == null ? P0.d : clamp(d, L.d[0], L.d[1]);
+    return { w: r2(ww), d: r2(dd) };
+  }
+  function buildPlan(tpl, wIn, dIn, opIn, bc = {}) {
+    const op = opIn || {};
+    const { w, d } = clampSize(tpl, wIn, dIn, op);
+    const styleId = resolveStyleId(op.style || (typeof tpl.style === "function" ? tpl.style(op) : tpl.style) || "budget");
+    const FLOOR_DEFS = floorsOf(tpl, op);
+    const style = styleOf(styleId);
+    const plan = {
+      w,
+      d,
+      tpl,
+      floorDefs: FLOOR_DEFS,
+      style: styleId,
+      floors: [],
+      rooms: [],
+      zones: [],
+      doors: [],
+      windows: [],
+      walls: [],
+      gates: [],
+      paths: [],
+      lot: null,
+      openPairs: {},
+      reservations: [],
+      options: op,
+      playerRadius: op.playerRadius ?? PLAYER_RADIUS,
+      carClearance: Object.assign({}, CAR_CLEARANCE, op.carClearance)
+    };
+    FLOOR_DEFS.forEach((A, floorIndex) => {
+      const floorNumber = tpl.singleFloor ? op.floor || 3 : floorIndex + 1;
+      plan.floors.push({
+        index: floorIndex,
+        name: tpl.singleFloor ? "floor_n" : A.label,
+        number: tpl.singleFloor ? floorNumber : void 0,
+        y0: tpl.singleFloor ? (floorNumber - 1) * A.ceiling : tpl.cumulativeCeilings ? FLOOR_DEFS.slice(0, floorIndex).reduce((t, q) => t + q.ceiling, 0) : floorIndex * A.ceiling,
+        ceiling: A.ceiling
+      });
+      plan.openPairs[floorIndex] = A.openPairs || [];
+      const list = A.rooms(w, d, op).map((c) => normalizeRoom(c, floorIndex));
+      for (const c of list) {
+        if (plan.rooms.some((x) => x.id === c.id)) throw new Error("Duplicate room: " + c.id);
+        plan.rooms.push(c);
+      }
+      const byId2 = {};
+      for (const c of list) byId2[c.id] = c;
+      const floorDoors = [];
+      (A.doors(w, d, op) || []).forEach((sp, i) => {
+        const a = byId2[sp.a];
+        if (!a) throw new Error("Door references a missing room: " + sp.a);
+        let edge;
+        if (sp.edge) edge = sp.edge;
+        else if (sp.b === "outside") edge = exteriorEdge(a, sp.side, w, d, sp.at);
+        else {
+          const b = byId2[sp.b];
+          if (!b) throw new Error("Door references a missing room: " + sp.b);
+          edge = sharedEdge(a, b, sp.at);
+        }
+        if (!edge) throw new Error("Door without a wall: " + sp.a + " / " + sp.b);
+        const width = sp.width;
+        const margin = width / 2 + (sp.clearance ?? tpl.clearance?.door ?? DOOR_EDGE_CLEARANCE);
+        if (edge.a1 - edge.a0 < width + 0.24) throw new Error("Wall too short for the door: " + sp.a + " / " + sp.b);
+        const c = clamp(sp.at != null ? sp.at : (edge.a0 + edge.a1) / 2, edge.a0 + margin, edge.a1 - margin);
+        const exterior = sp.b === "outside";
+        const leaf = exterior && sp.steel ? 0 : width > 1.1 ? width / 2 : width;
+        const u = edge.axis === "u" ? c : edge.pos;
+        const v = edge.axis === "u" ? edge.pos : c;
+        floorDoors.push({
+          id: "d" + floorIndex + "_" + i,
+          floor: floorIndex,
+          u: r2(u),
+          v: r2(v),
+          axis: edge.axis,
+          pos: edge.pos,
+          at: r2(c),
+          width,
+          a: sp.a,
+          b: sp.b,
+          opensTo: sp.opensTo || sp.a,
+          exterior,
+          side: sp.side || null,
+          leaves: exterior && sp.steel ? 0 : width > 1.1 ? 2 : 1,
+          model: sp.model || (sp.steel ? "steel" : width > 1.1 ? "double" : "single"),
+          type: sp.type || "door",
+          steps: sp.steps || 0,
+          hinge: "start",
+          zones: openingZones(u, v, edge.axis, width, openingDepth(width, leaf))
+        });
+      });
+      plan.doors.push(...floorDoors);
+      const floorWalls = (tpl.noWalls ? [] : buildWalls(list, floorDoors, A.openPairs || [], floorIndex)).map((p) => Object.assign(p, { h: p.h || A.ceiling }));
+      const windowsOut = placeWindows({ list, byId: byId2, floorWalls, windowDefs: A.windows(w, d, op) || [], floorIndex, ceiling: A.ceiling, w, d, clearance: tpl.clearance?.window ?? WINDOW_EDGE_CLEARANCE });
+      plan.windows.push(...windowsOut);
+      plan.walls.push(...floorWalls);
+    });
+    if (tpl.config) plan.config = tpl.config(op, w, d);
+    if (tpl.reservations) tpl.reservations(plan);
+    buildLot(plan, tpl, w, d, op, style, styleId, bc);
+    return plan;
+  }
+  function placeWindows(params) {
+    const { list, byId: byId2, floorWalls, windowDefs, floorIndex, ceiling, w, d, clearance } = params;
+    const stretches = floorWalls.filter((p) => p.exterior && p.type === "wall");
+    const found = [];
+    const groups = [];
+    let order = 0;
+    for (const def of windowDefs) {
+      const room = byId2[def.room];
+      if (!room) throw new Error("Window references a missing room: " + def.room);
+      const edge = exteriorEdge(room, def.side, w, d, def.at);
+      if (!edge) continue;
+      const centres = def.n ? Array.from({ length: def.n }, (_, i) => edge.a0 + (edge.a1 - edge.a0) * (i + 1) / (def.n + 1)) : [def.at];
+      for (const centre of centres) {
+        const onEdge = stretches.filter((t) => t.axis === edge.axis && eq(edge.axis === "u" ? t.v0 : t.u0, edge.pos) && t.sides.includes(def.room));
+        const start = (t) => edge.axis === "u" ? t.u0 : t.v0;
+        const end = (t) => edge.axis === "u" ? t.u1 : t.v1;
+        const gap = (t) => Math.min(Math.abs(centre - start(t)), Math.abs(centre - end(t)));
+        const target = onEdge.find((t) => centre >= start(t) - TOL && centre <= end(t) + TOL) || onEdge.slice().sort((x, y) => gap(x) - gap(y))[0];
+        if (!target) continue;
+        let group = groups.find((x) => x.wall === target && x.def.room === def.room);
+        if (!group) groups.push(group = { wall: target, edge, start: start(target), end: end(target), def, entries: [] });
+        group.entries.push({ def, centre, order: order++ });
+      }
+    }
+    for (const g of groups) {
+      const room = byId2[g.def.room];
+      const bath = room.type === "bathroom";
+      const length = g.end - g.start;
+      const its = g.entries.slice().sort((x, y) => x.centre - y.centre).map((x) => ({ def: x.def, order: x.order, width: bath ? Math.min(x.def.width, 0.6) : x.def.width }));
+      const fits = (l) => l.reduce((t, x) => t + x.width, 0) + (l.length + 1) * clearance <= length + TOL;
+      while (its.length && !fits(its)) {
+        const k = its.reduce((m, x, i, arr) => x.width > arr[m].width ? i : m, 0);
+        if (its[k].width > 0.6 + TOL) its[k] = Object.assign({}, its[k], { width: Math.max(0.6, r2(its[k].width - 0.1)) });
+        else its.pop();
+      }
+      if (!its.length) continue;
+      const space = (length - its.reduce((t, x) => t + x.width, 0)) / (its.length + 1);
+      let pos = g.start + space;
+      for (const x of its) {
+        const c = pos + x.width / 2;
+        pos += x.width + space;
+        const u = g.edge.axis === "u" ? c : g.edge.pos;
+        const v = g.edge.axis === "u" ? g.edge.pos : c;
+        let y0 = x.def.y0 || 1;
+        let y1 = x.def.y1 || 2.15;
+        if (bath) {
+          y0 = Math.max(y0, 2.1);
+          y1 = Math.min(Math.max(y1, y0 + 0.4), ceiling - 0.25);
+        }
+        found.push({ id: "", floor: floorIndex, u: r2(u), v: r2(v), axis: g.edge.axis, pos: g.edge.pos, at: r2(c), width: x.width, y0: r2(y0), y1: r2(y1), room: x.def.room, side: x.def.side, _order: x.order });
+      }
+    }
+    for (const room of list) {
+      if (WINDOWLESS_ROOM_TYPES.has(room.type) || found.some((j) => j.room === room.id)) continue;
+      let best = null;
+      for (const t of stretches) {
+        if (!t.sides.includes(room.id)) continue;
+        const i0 = t.axis === "u" ? t.u0 : t.v0;
+        const i1 = t.axis === "u" ? t.u1 : t.v1;
+        const length = i1 - i0;
+        const width = Math.min(room.type === "bathroom" ? 0.6 : 1.2, length - 2 * clearance);
+        if (width < 0.6 - TOL || best && best.length >= length) continue;
+        const side = t.axis === "u" ? t.sides[0] === "outside" ? "front" : "back" : t.sides[0] === "outside" ? "left" : "right";
+        const c = (i0 + i1) / 2;
+        const pos = t.axis === "u" ? t.v0 : t.u0;
+        const bath = room.type === "bathroom";
+        best = { length, window: { id: "", floor: floorIndex, u: r2(t.axis === "u" ? c : pos), v: r2(t.axis === "u" ? pos : c), axis: t.axis, pos, at: r2(c), width: r2(width), y0: bath ? 2.1 : 1, y1: bath ? Math.min(2.5, ceiling - 0.25) : 2.15, room: room.id, side, _order: 1e6 + found.length } };
+      }
+      if (best) found.push(best.window);
+    }
+    found.sort((x, y) => x._order - y._order);
+    found.forEach((j, i) => {
+      delete j._order;
+      j.id = "w" + floorIndex + "_" + i;
+    });
+    return found;
+  }
+  function buildLot(plan, tpl, w, d, op, style, styleId, bc) {
+    const seed = op.seed == null ? 1 : op.seed;
+    const rFacade = createRng(seed, STREAM.facade);
+    const facadeStyle = style.facade;
+    const palette2 = style.swatches;
+    const color = palette2[Math.floor(rFacade() * palette2.length)];
+    const extra = tpl.facade || {};
+    plan.facade = {
+      style: styleId,
+      color: { name: color[0], hex: color[1] },
+      finish: pickWeighted(rFacade, facadeStyle.finish),
+      grilles: rFacade() < facadeStyle.grilles,
+      roof: pickWeighted(rFacade, facadeStyle.roof),
+      balcony: !!extra.balcony,
+      veranda: !!extra.veranda,
+      steelDoor: !!extra.steelDoor,
+      floors: plan.floorDefs.length
+    };
+    if (tpl.facadeExtra) tpl.facadeExtra(plan.facade, rFacade, w, d, op);
+    if (plan.floorDefs.length > 1 && plan.facade.roof === "fiber_cement") plan.facade.roof = "colonial";
+    if (!tpl.lot) return;
+    const cfg = tpl.lot(w, d, style, op);
+    if (bc.zone) clampLotToZone(cfg, bc.zone, bc.adjustments || [], tpl.partyWalls);
+    const rLot = createRng(seed, STREAM.lot);
+    const setback = cfg.frontSetback;
+    const marginL = cfg.marginLeft;
+    const marginR = cfg.marginRight;
+    const backDepth = cfg.backyardDepth;
+    const lot = {
+      rect: [-marginL, -setback, w + marginR, d + backDepth],
+      setback,
+      sideYard: { left: marginL, right: marginR },
+      backyard: backDepth,
+      style: styleId,
+      zones: [],
+      perimeter: [],
+      gates: [],
+      paths: [],
+      pool: !!cfg.pool
+    };
+    const ZONES = [];
+    const libs = Object.assign({ garden: "garden", backyard: "backyard", parking: "parking", sideYard: "side_yard" }, cfg.libraries || {});
+    const addZone = (id, type, label, parts, library) => ZONES.push(Object.assign(normalizeRoom({ id, type, label, rect: parts[0], parts: parts.slice(1), library, outdoor: true }, -1), { floor: -1, outdoor: true }));
+    if (setback > 0) {
+      let parts = [[-marginL, -setback, w + marginR, 0]];
+      if (cfg.parking) {
+        const garageU = cfg.garage.u;
+        const vw = cfg.parking.width;
+        const x0 = Math.max(-marginL, garageU - vw / 2);
+        const x1 = Math.min(w + marginR, garageU + vw / 2);
+        parts = [];
+        if (x0 + marginL > 0.8) parts.push([-marginL, -setback, x0, 0]);
+        if (w + marginR - x1 > 0.8) parts.push([x1, -setback, w + marginR, 0]);
+        addZone("parking", "parking", "parking", [[x0, -setback, x1, 0]], libs.parking);
+        if (!parts.length) parts = [[x1, -setback, w + marginR, 0]];
+      }
+      parts.sort((a, b) => b[2] - b[0] - (a[2] - a[0]));
+      addZone("garden", "garden", "garden", parts, libs.garden);
+    }
+    const yard = cfg.yardZones;
+    if (backDepth > 0 && yard) {
+      for (const q of yard) addZone(q.id, q.type, q.label || q.id, [[-marginL, d + q.v0, w + marginR, d + Math.min(backDepth, q.v1)]], q.library);
+    } else if (backDepth > 0) addZone("backyard", "backyard", "backyard", [[-marginL, d, w + marginR, d + backDepth]], libs.backyard);
+    for (const q of cfg.extraZones || []) addZone(q.id, q.type, q.label || q.id, q.parts, q.library);
+    if (marginL > 0.5) addZone("side_left", "side_yard", "side_left", [[-marginL, 0, 0, d]], libs.sideYard);
+    if (marginR > 0.5) addZone("side_right", "side_yard", "side_right", [[w, 0, w + marginR, d]], libs.sideYard);
+    const gates = [];
+    const addGate = (type, model, u, v, width, side, toTarget) => {
+      const g = {
+        id: "g" + gates.length,
+        type,
+        model,
+        u: r2(u),
+        v: r2(v),
+        axis: "u",
+        width,
+        height: type === "pedestrian" ? style.height : Math.min(style.height, 2.2),
+        side,
+        to: toTarget || null,
+        material: "iron",
+        zones: openingZones(u, v, "u", width, openingDepth(width, type === "pedestrian" ? width : 0))
+      };
+      gates.push(g);
+      return g;
+    };
+    if (cfg.pedestrian && setback > 0) addGate("pedestrian", "pedestrian", cfg.pedestrian.u, -setback, 1, "front", "door");
+    if (cfg.garage && setback > 0) addGate("garage", pickWeighted(rLot, style.gate.garage), cfg.garage.u, -setback, cfg.garage.width, "front", cfg.garage.to);
+    if (cfg.cargo) addGate("cargo", "sliding", cfg.cargo.u, d + backDepth, cfg.cargo.width, "back", "stockroom");
+    plan.gates = gates;
+    lot.gates = gates;
+    const paths = [];
+    const target = (a, side) => plan.doors.find((p) => p.exterior && p.a === a && p.side === side);
+    for (const g of gates) {
+      if (g.type === "pedestrian" && cfg.doorTarget) {
+        const pt = target(cfg.doorTarget.a, cfg.doorTarget.side);
+        if (!pt) continue;
+        const gateU = g.u;
+        const dx = pt.u;
+        const ym = -setback / 2;
+        const L = 1;
+        const h = L / 2;
+        const rs = [];
+        if (Math.abs(gateU - dx) < 0.05) rs.push([dx - h, -setback, dx + h, 0]);
+        else {
+          rs.push([gateU - h, -setback, gateU + h, ym + h]);
+          rs.push([Math.min(gateU, dx) - h, ym - h, Math.max(gateU, dx) + h, ym + h]);
+          rs.push([dx - h, ym - h, dx + h, 0]);
+        }
+        paths.push({ id: "pedestrian_path", type: "pedestrian", from: g.id, to: pt.id, width: L, rects: rs.map((r) => r.map(r2)), points: [[gateU, -setback], [gateU, ym], [dx, ym], [dx, 0]] });
+      } else if (g.type === "garage" && g.to === "inner_garage") {
+        const pt = plan.doors.find((p) => p.exterior && p.side === "front" && Math.abs(p.u - g.u) < 0.6 && p.width >= 2.5);
+        if (!pt) continue;
+        const hw = Math.max(g.width, pt.width) / 2;
+        paths.push({ id: "garage_path", type: "vehicle", from: g.id, to: pt.id, width: hw * 2, rects: [[g.u - hw, -setback, g.u + hw, 0].map(r2)], points: [[g.u, -setback], [g.u, 0]] });
+      } else if (g.type === "cargo") {
+        const pt = target("stockroom", "back");
+        if (!pt) continue;
+        const hw = Math.max(g.width, pt.width) / 2;
+        paths.push({ id: "cargo_path", type: "vehicle", from: g.id, to: pt.id, width: hw * 2, rects: [[g.u - hw, d, g.u + hw, d + backDepth].map(r2)], points: [[g.u, d + backDepth], [g.u, d]] });
+      }
+    }
+    if (tpl.paths) paths.push(...tpl.paths(plan, { gates, setback, marginLeft: marginL, marginRight: marginR, backyard: backDepth, w, d }));
+    else addExteriorDoorPaths(plan, { gates, paths, zones: ZONES, setback, marginLeft: marginL, marginRight: marginR, backyard: backDepth, w, target: cfg.doorTarget });
+    plan.paths = paths;
+    lot.paths = paths;
+    const boundary = (rule) => {
+      const type = pickWeighted(rLot, rule.type);
+      const top = type === "railing" ? "none" : pickWeighted(rLot, rule.top);
+      const wallHeight = type === "railing" ? 1.2 : type === "fence" ? style.fenceHeight ?? 2 : style.height;
+      return { type, material: type === "wall" ? "block" : type === "fence" ? "wire_mesh" : "iron", height: wallHeight, top, totalHeight: r2(wallHeight + registries().WALL_TOP_HEIGHTS[top]), thickness: WALL_THICKNESS };
+    };
+    const A = { front: boundary(style.front), left: boundary(style.sideYard), right: boundary(style.sideYard), back: boundary(style.back) };
+    const seg = (side, u0, v0, u1, v1) => {
+      if (Math.abs(u1 - u0) + Math.abs(v1 - v0) < 0.05) return;
+      lot.perimeter.push(Object.assign({ id: "m" + lot.perimeter.length, side, u0: r2(u0), v0: r2(v0), u1: r2(u1), v1: r2(v1) }, A[side]));
+    };
+    const cutRun = (side, de, to, vfix, gs) => {
+      let pieces = [[de, to]];
+      for (const g of gs) {
+        const g0 = g.u - g.width / 2;
+        const g1 = g.u + g.width / 2;
+        const n = [];
+        for (const [x, y] of pieces) {
+          if (g1 <= x || g0 >= y) {
+            n.push([x, y]);
+            continue;
+          }
+          if (g0 > x) n.push([x, g0]);
+          if (g1 < y) n.push([g1, y]);
+        }
+        pieces = n;
+      }
+      for (const [x, y] of pieces) seg(side, x, vfix, y, vfix);
+    };
+    if (setback > 0)
+      cutRun("front", -marginL, w + marginR, -setback, gates.filter((g) => g.side === "front"));
+    cutRun("back", -marginL, w + marginR, d + backDepth, gates.filter((g) => g.side === "back"));
+    const vi = setback > 0 ? -setback : 0;
+    if (marginL > 0.5) seg("left", -marginL, vi, -marginL, d + backDepth);
+    else if (backDepth > 0) seg("left", 0, d, 0, d + backDepth);
+    if (marginR > 0.5) seg("right", w + marginR, vi, w + marginR, d + backDepth);
+    else if (backDepth > 0) seg("right", w, d, w, d + backDepth);
+    for (const z of ZONES) z.ground = (cfg.grounds || {})[z.id] || (cfg.grounds || {})[z.type] || pickWeighted(rLot, style.grounds[z.type] || { concrete: 1 });
+    if (bc.zone) enforcePermeability(lot, ZONES, bc.zone, bc.adjustments || []);
+    plan.zones = ZONES;
+    lot.zones = ZONES;
+    plan.lot = lot;
+  }
+  var HIGH_SATURATION = 0.4;
+  var MIN_WALL_FLOOR_CONTRAST = 20;
+  var MIN_FABRIC_FLOOR_CONTRAST = 15;
+  var SCHEMES = ["analogous", "complementary", "split_complementary", "triad"];
+  var HARMONY_OFFSETS = { analogous: [-30, 30], complementary: [180, 165], split_complementary: [150, 210], triad: [120, 240] };
+  var ROLE_FABRIC_MAIN = "fabric_main";
+  var ROLE_FABRIC_ACCENT = "fabric_accent";
+  var ROLE_FLOOR_REFERENCE = "floor_living";
+  var hslToInt = (h, s, l) => {
+    h = (h % 360 + 360) % 360;
+    s = clamp(s, 0, 1);
+    l = clamp(l, 0, 1);
+    const a = s * Math.min(l, 1 - l);
+    const f = (n) => {
+      const k = (n + h / 30) % 12;
+      return l - a * Math.max(-1, Math.min(k - 3, 9 - k, 1));
+    };
+    return Math.round(f(0) * 255) << 16 | Math.round(f(8) * 255) << 8 | Math.round(f(4) * 255);
+  };
+  var intToHsl = (n) => {
+    const r = (n >> 16 & 255) / 255;
+    const g = (n >> 8 & 255) / 255;
+    const b = (n & 255) / 255;
+    const mx = Math.max(r, g, b);
+    const mn = Math.min(r, g, b);
+    const l = (mx + mn) / 2;
+    const d = mx - mn;
+    let h = 0;
+    let s = 0;
+    if (d > 1e-9) {
+      s = d / (1 - Math.abs(2 * l - 1));
+      h = mx === r ? (g - b) / d + (g < b ? 6 : 0) : mx === g ? (b - r) / d + 2 : (r - g) / d + 4;
+      h *= 60;
+    }
+    return { h, s, l };
+  };
+  var lstar = (n) => {
+    const linear = (c) => (c /= 255) <= 0.04045 ? c / 12.92 : Math.pow((c + 0.055) / 1.055, 2.4);
+    const Y = 0.2126 * linear(n >> 16 & 255) + 0.7152 * linear(n >> 8 & 255) + 0.0722 * linear(n & 255);
+    return Y > 216 / 24389 ? 116 * Math.cbrt(Y) - 16 : Y * 24389 / 27;
+  };
+  var hexString = (n) => "#" + (n >>> 0).toString(16).padStart(6, "0");
+  function palette(o) {
+    const opt = o || {};
+    let style = resolveStyleId(opt.style || "budget");
+    if (!registries().PALETTE_STYLES[style]) style = registries().PALETTE_STYLES.mid ? "mid" : Object.keys(registries().PALETTE_STYLES)[0];
+    const def = registries().PALETTE_STYLES[style];
+    const state = opt.state || "normal";
+    const seed = opt.seed == null ? 1 : opt.seed;
+    const rng = createRng(seed, STREAM.palettePrefix + (def.seedKey ?? style));
+    const table = def.facadeColors;
+    const base = table[Math.floor(rng() * table.length)];
+    const scheme = SCHEMES[Math.floor(rng() * 4)];
+    const offsets = HARMONY_OFFSETS[scheme];
+    const jit = (v, a) => v + (rng() - 0.5) * a;
+    const hsl = (h, s, l) => ({ h: (h % 360 + 360) % 360, s: clamp(s, 0, 1), l: clamp(l, 0, 1) });
+    const H0 = base[1];
+    const H1 = H0 + offsets[0];
+    const H2 = H0 + offsets[1];
+    const draw = { rng, base, H0, H1, H2, jit, hsl };
+    const early = def.early(draw);
+    const { wallMode, sMax } = early;
+    const R = Object.assign({}, early.roles);
+    const ctx = Object.assign({ style, sMax, wallMode, generalFloor: early.generalFloor }, draw);
+    for (const c of registries().ROOM_COLORS) {
+      const [wh, wl] = c.wall(ctx);
+      R["wall_" + c.type] = hsl(wh, c.neutral ? Math.min(0.16, sMax) : clamp(jit(sMax * 0.75, sMax * 0.5), 0.03, sMax), jit(wl, 0.03));
+      const pi = c.floor || early.generalFloor;
+      R["floor_" + c.type] = hsl(pi[0], Math.min(pi[1], wallMode ? 0.18 : 0.3), jit(pi[2], 0.04));
+    }
+    Object.assign(R, def.late(draw, early));
+    registries().STATE_PLUGINS[state]?.adjustPalette?.(R);
+    const adjust = (color, ref, min, preferredDir) => {
+      for (let i = 0; i < 60; i++) {
+        if (Math.abs(lstar(hslToInt(color.h, color.s, color.l)) - lstar(hslToInt(ref.h, ref.s, ref.l))) >= min) return;
+        const refL = lstar(hslToInt(ref.h, ref.s, ref.l));
+        let dir = preferredDir || (refL > 50 ? -1 : 1);
+        if (dir < 0 && color.l <= 0.06 || dir > 0 && color.l >= 0.94) dir = -dir;
+        color.l = clamp(color.l + dir * 0.015, 0.04, 0.96);
+      }
+    };
+    const types = registries().ROOM_COLORS.map((c) => c.type);
+    for (const c of types) {
+      const w = R["wall_" + c];
+      const p = R["floor_" + c];
+      if (w.s > 0.3) p.s = Math.min(p.s, 0.2);
+      if (p.s > HIGH_SATURATION) p.s = HIGH_SATURATION - 0.05;
+      adjust(p, w, MIN_WALL_FLOOR_CONTRAST + 2, lstar(hslToInt(w.h, w.s, w.l)) > 50 ? -1 : 1);
+    }
+    const floorRef = R[ROLE_FLOOR_REFERENCE] || R["floor_" + types[0]];
+    const fabric = R[ROLE_FABRIC_MAIN];
+    adjust(fabric, floorRef, MIN_FABRIC_FLOOR_CONTRAST + 3);
+    adjust(R[ROLE_FABRIC_ACCENT], floorRef, MIN_FABRIC_FLOOR_CONTRAST + 3);
+    for (const c of types) {
+      const p = R["floor_" + c];
+      if (Math.abs(lstar(hslToInt(fabric.h, fabric.s, fabric.l)) - lstar(hslToInt(p.h, p.s, p.l))) < MIN_FABRIC_FLOOR_CONTRAST)
+        adjust(p, fabric, MIN_FABRIC_FLOOR_CONTRAST + 2, lstar(hslToInt(fabric.h, fabric.s, fabric.l)) > 50 ? -1 : 1);
+    }
+    const out = { meta: { seed, style, state, scheme, base: base[0], accentMode: wallMode ? "wall" : "object" } };
+    for (const k of Object.keys(R)) out[k] = hslToInt(R[k].h, R[k].s, R[k].l);
+    const num = (k) => out[k];
+    const pairOk = (w, p) => Math.abs(lstar(w) - lstar(p)) >= MIN_WALL_FLOOR_CONTRAST + 1 && Math.abs(lstar(num(ROLE_FABRIC_MAIN)) - lstar(p)) >= MIN_FABRIC_FLOOR_CONTRAST + 1;
+    const search = (color, ok) => {
+      const h = intToHsl(color);
+      let bestValue = null;
+      let md = 9;
+      for (let l = 0.02; l <= 0.98; l += 5e-3) {
+        const n = hslToInt(h.h, h.s, l);
+        if (ok(n) && Math.abs(l - h.l) < md) {
+          md = Math.abs(l - h.l);
+          bestValue = n;
+        }
+      }
+      return bestValue;
+    };
+    for (const c of types) {
+      if (pairOk(num("wall_" + c), num("floor_" + c))) continue;
+      const n = search(num("floor_" + c), (p) => pairOk(num("wall_" + c), p));
+      if (n != null) {
+        out["floor_" + c] = n;
+        continue;
+      }
+      const w = search(num("wall_" + c), (w2) => pairOk(w2, num("floor_" + c)));
+      if (w != null) out["wall_" + c] = w;
+    }
+    return out;
+  }
+  var SIDE_NORMAL = { left: [1, 0], right: [-1, 0], front: [0, 1], back: [0, -1] };
+  var FIXED_FACING = { "u+": [1, 0], "u-": [-1, 0], "v+": [0, 1], "v-": [0, -1] };
+  var SIDE_OPPOSITE = { front: "back", back: "front", left: "right", right: "left" };
+  var WINDOW_SIDE = { front: "front", back: "back", left: "left", right: "right" };
+  function slotDefsOf(plan, room) {
+    const name = room.library || room.type;
+    const key = registries().LIBRARY_ALIAS[name] || name;
+    const library = room.slots ? room.slots : registries().LIBRARIES[key];
+    if (!library) return [];
+    const R = inner(room.parts[0]);
+    let defs = typeof library === "function" ? library({ w: R[2] - R[0], d: R[3] - R[1] }) : library.slice();
+    defs = defs.map((x) => Object.assign({}, x));
+    for (const id of room.without || []) defs = defs.filter((x) => x.id !== id);
+    for (const [id, aj] of Object.entries(room.overrides || {})) {
+      const i = defs.findIndex((x) => x.id === id);
+      if (i < 0) continue;
+      if (aj === null) defs.splice(i, 1);
+      else defs[i] = Object.assign(defs[i], aj);
+    }
+    defs.push(...(room.extras || []).map((x) => Object.assign({}, x)));
+    const out = [];
+    for (const def of defs) {
+      def.parent = def.on;
+      if (def.anchor === "wall" && def.side === "any") for (const l of ["left", "right", "front", "back"]) out.push(Object.assign({}, def, { id: def.id + "@" + l, side: l, group: def.group || def.id }));
+      else if (def.anchor === "corner" && def.corner === "any") for (const l of ["front-left", "front-right", "back-left", "back-right"]) out.push(Object.assign({}, def, { id: def.id + "@" + l, corner: l, group: def.group || def.id }));
+      else if (def.anchor === "window" && def.n == null) {
+        const windowList = windowsOfRoom(plan, room);
+        windowList.forEach((_j, i) => out.push(Object.assign({}, def, { id: def.id + "@w" + i, n: i, group: def.group || def.id })));
+      } else out.push(def);
+    }
+    return out;
+  }
+  function resolveSlots(plan) {
+    const all = [];
+    for (const room of plan.rooms.concat(plan.zones)) {
+      const defs = slotDefsOf(plan, room);
+      const byId2 = {};
+      const zones = room.type === "stairs" ? plan.floors.flatMap((_, floorIndex) => zonesOfFloor(plan, floorIndex)) : zonesOfFloor(plan, room.floor);
+      for (const def of defs) {
+        const s = resolveSlot(plan, room, def, byId2, zones);
+        byId2[def.id] = s;
+        all.push(s);
+      }
+    }
+    return all;
+  }
+  function resolveSlot(plan, room, def, byId2, zones) {
+    const base = {
+      id: def.id,
+      room: room.id,
+      floor: room.floor,
+      outdoor: room.outdoor,
+      anchor: def.anchor,
+      side: def.side || def.corner || null,
+      cats: def.cats,
+      slide: def.slide,
+      required: !!def.required,
+      chance: def.required ? 1 : def.chance == null ? 1 : def.chance,
+      clearance: def.clearance == null ? 0.5 : def.clearance,
+      front: def.facing || "center",
+      group: def.group || null,
+      requires: def.requires || null,
+      on: def.parent || null,
+      target: def.target || null,
+      valid: true,
+      reason: null
+    };
+    const invalid = (m) => Object.assign(base, { valid: false, reason: m, x: 0, z: 0, ry: 0, w: 0, d: 0, frontU: 0, frontV: 1, aabb: [0, 0, 0, 0], _cell: null });
+    if (def.anchor === "on" || def.anchor === "inside") {
+      const parent = def.parent ? byId2[def.parent] : void 0;
+      if (!parent || !parent.valid) return invalid("invalid_parent");
+      return Object.assign(base, { x: parent.x, z: parent.z, ry: parent.ry, w: parent.w, d: parent.d, frontU: parent.frontU, frontV: parent.frontV, aabb: parent.aabb, _cell: parent._cell });
+    }
+    const size = def.size;
+    const roomCenter = (() => {
+      const R0 = inner(room.parts[0]);
+      return [(R0[0] + R0[2]) / 2, (R0[1] + R0[3]) / 2];
+    })();
+    const openings = openingsOfFloor(plan, room.floor);
+    let point = [0, 0];
+    const targetPoint = (rule2) => {
+      if (rule2 === "door") {
+        let best = null;
+        let bestDist = 1e9;
+        for (const ab of openings) {
+          const dist = Math.hypot(ab.u - point[0], ab.v - point[1]);
+          if (dist < bestDist) {
+            bestDist = dist;
+            best = ab;
+          }
+        }
+        return best ? [best.u, best.v] : roomCenter;
+      }
+      if (rule2 === "target") {
+        const t = byId2[def.target];
+        return t && t.valid ? [t.x, t.z] : roomCenter;
+      }
+      return roomCenter;
+    };
+    const free = (rect) => !!def.floorFree || !zones.some((z) => overlaps(rect, z, room.type === "stairs" ? -0.011 : EPS));
+    const rule = def.facing || "center";
+    let R = inner(room.parts[Math.min(def.part || 0, room.parts.length - 1)]);
+    if (def.anchor === "wall" || def.anchor === "window") {
+      let side = def.side;
+      let a = null;
+      let win = null;
+      if (def.anchor === "window") {
+        const windowList = windowsOfRoom(plan, room);
+        win = windowList[def.n];
+        if (!win) return invalid("no_window");
+        const found2 = win;
+        side = room.outdoor ? SIDE_OPPOSITE[win.side] : WINDOW_SIDE[win.side];
+        const cand = room.parts.map(inner).find(
+          (r) => (found2.axis === "u" ? found2.u >= r[0] - TOL && found2.u <= r[2] + TOL : found2.v >= r[1] - TOL && found2.v <= r[3] + TOL) && (side === "left" && eq(r[0], found2.pos + MARGIN) || side === "right" && eq(r[2], found2.pos - MARGIN) || side === "front" && eq(r[1], found2.pos + MARGIN) || side === "back" && eq(r[3], found2.pos - MARGIN))
+        );
+        if (!cand) return invalid("window_outside_room");
+        R = cand;
+        a = win.axis === "u" ? win.u : win.v;
+      }
+      const n = SIDE_NORMAL[side];
+      if (!n) return invalid("invalid_side");
+      const horizontal = side === "front" || side === "back";
+      const a0 = horizontal ? R[0] : R[1];
+      const a1 = horizontal ? R[2] : R[3];
+      const len = a1 - a0;
+      const depth = size[1];
+      if (depth > (horizontal ? R[3] - R[1] : R[2] - R[0]) + EPS) return invalid("larger_than_room");
+      const hw = Math.min(size[0], len) / 2;
+      const cell = (ac) => side === "left" ? [R[0], ac - hw, R[0] + depth, ac + hw] : side === "right" ? [R[2] - depth, ac - hw, R[2], ac + hw] : side === "front" ? [ac - hw, R[1], ac + hw, R[1] + depth] : [ac - hw, R[3] - depth, ac + hw, R[3]];
+      const nominal = a != null ? a : a0 + hw + (def.pos == null ? 0.5 : def.pos) * Math.max(0, len - 2 * hw) + (def.shift || 0);
+      const wp = side === "left" ? R[0] - MARGIN : side === "right" ? R[2] + MARGIN : side === "front" ? R[1] - MARGIN : R[3] + MARGIN;
+      const pa = clamp(nominal, a0 + hw, a1 - hw);
+      let found = null;
+      const steps = [0];
+      if (def.anchor !== "window") for (let k = 1; k <= 60; k++) steps.push(k, -k);
+      for (const k of steps) {
+        const ac = pa + k * 0.05;
+        if (ac - hw < a0 - EPS || ac + hw > a1 + EPS) continue;
+        if (free(cell(ac))) {
+          found = ac;
+          break;
+        }
+      }
+      if (found == null) return invalid("blocked_by_door");
+      const sp = horizontal ? [found, wp - n[1] * 0.1] : [wp - n[0] * 0.1, found];
+      if (isOpenSide(plan, room, sp[0], sp[1])) return invalid("open_wall");
+      const rect = cell(found);
+      return Object.assign(base, { side, x: r2((rect[0] + rect[2]) / 2), z: r2((rect[1] + rect[3]) / 2), frontU: n[0], frontV: n[1], ry: r2(Math.atan2(n[0], n[1])), w: size[0], d: size[1], aabb: rect.map(r2), _cell: { rect, f: n, enclosed: [side], R, size } });
+    }
+    if (def.anchor === "corner") {
+      const [cornerV, cornerU] = def.corner.split("-");
+      const normalV = SIDE_NORMAL[cornerV];
+      const normalU = SIDE_NORMAL[cornerU];
+      if (!normalV || !normalU) return invalid("invalid_corner");
+      const kx = cornerU === "left" ? R[0] : R[2];
+      const kz = cornerV === "front" ? R[1] : R[3];
+      point = [kx, kz];
+      let f;
+      if (FIXED_FACING[rule]) {
+        f = FIXED_FACING[rule];
+        if (!(f[0] === normalU[0] && f[1] === normalU[1] || f[0] === normalV[0] && f[1] === normalV[1])) f = normalU;
+      } else {
+        const t = targetPoint(rule);
+        f = Math.abs(t[0] - kx) >= Math.abs(t[1] - kz) ? normalU : normalV;
+      }
+      const [extentU, extentV] = extent(size, f);
+      if (extentU > R[2] - R[0] + EPS || extentV > R[3] - R[1] + EPS) return invalid("larger_than_room");
+      const rect = [cornerU === "left" ? R[0] : R[2] - extentU, cornerV === "front" ? R[1] : R[3] - extentV, cornerU === "left" ? R[0] + extentU : R[2], cornerV === "front" ? R[1] + extentV : R[3]];
+      if (!free(rect)) return invalid("blocked_by_door");
+      for (const sp of [[kx - normalU[0] * (MARGIN + 0.1), (rect[1] + rect[3]) / 2], [(rect[0] + rect[2]) / 2, kz - normalV[1] * (MARGIN + 0.1)]]) if (isOpenSide(plan, room, sp[0], sp[1])) return invalid("open_wall");
+      return Object.assign(base, { x: r2((rect[0] + rect[2]) / 2), z: r2((rect[1] + rect[3]) / 2), frontU: f[0], frontV: f[1], ry: r2(Math.atan2(f[0], f[1])), w: size[0], d: size[1], aabb: rect.map(r2), _cell: { rect, f, enclosed: [cornerU, cornerV], R, size } });
+    }
+    if (def.anchor === "center") {
+      let cx = R[0] + (def.fx == null ? 0.5 : def.fx) * (R[2] - R[0]) + (def.dx || 0);
+      let cz = R[1] + (def.fz == null ? 0.5 : def.fz) * (R[3] - R[1]) + (def.dz || 0);
+      point = [cx, cz];
+      let f;
+      if (FIXED_FACING[rule]) f = FIXED_FACING[rule];
+      else {
+        const t = targetPoint(rule);
+        const dx = t[0] - cx;
+        const dz = t[1] - cz;
+        f = Math.hypot(dx, dz) < 0.05 ? [0, 1] : cardinal(dx, dz);
+      }
+      const [extentU, extentV] = extent(size, f);
+      if (extentU > R[2] - R[0] + EPS || extentV > R[3] - R[1] + EPS) return invalid("larger_than_room");
+      cx = clamp(cx, R[0] + extentU / 2, R[2] - extentU / 2);
+      cz = clamp(cz, R[1] + extentV / 2, R[3] - extentV / 2);
+      const rect = [cx - extentU / 2, cz - extentV / 2, cx + extentU / 2, cz + extentV / 2];
+      if (!free(rect)) return invalid("blocked_by_door");
+      return Object.assign(base, { x: r2(cx), z: r2(cz), frontU: f[0], frontV: f[1], ry: r2(Math.atan2(f[0], f[1])), w: size[0], d: size[1], aabb: rect.map(r2), _cell: { rect, f, enclosed: [], R, size } });
+    }
+    return invalid("unknown_anchor");
+  }
+  function templateOf(t) {
+    if (typeof t === "string") {
+      if (!registries().TEMPLATES[t]) throw new Error("Unknown template: " + t);
+      return registries().TEMPLATES[t];
+    }
+    return t;
+  }
+  var cleanSlot = (s) => {
+    const o = {};
+    for (const k of Object.keys(s)) if (k[0] !== "_") o[k] = s[k];
+    o.cats = Object.keys(s.cats || {});
+    return o;
+  };
+  function slots(template, options) {
+    const tpl = templateOf(template);
+    const o = options || {};
+    const plan = buildPlan(tpl, o.w, o.d, o);
+    const locale = o.locale || "en";
+    return resolveSlots(plan).map(cleanSlot).map((s) => s.reason ? Object.assign(s, { reason: translate("reasons", s.reason, locale) }) : s);
+  }
+  function pickState(requested, seed) {
+    if (requested && registries().STATE_PLUGINS[requested]) return requested;
+    const dist = registries().stateDistribution.weights;
+    if (!dist) return "normal";
+    const x = createRng(seed, registries().stateDistribution.seedKey)();
+    let acc = 0;
+    const keys = Object.keys(dist);
+    for (const k of keys) {
+      acc += dist[k];
+      if (x < acc) return k;
+    }
+    return keys[keys.length - 1];
+  }
+  function colorOf(m, seed) {
+    const spec = m.colorSpec || registries().CATALOG[m.type]?.color || { role: "wood" };
+    if ("role" in spec) return spec.role;
+    if ("hex" in spec) return spec.hex;
+    return spec.pick[hashString(seed + "|" + (m._seedId ?? m.id)) % spec.pick.length];
+  }
+  function applyState(plan, items, ctx, seed, state) {
+    const plugin = registries().STATE_PLUGINS[state];
+    if (!plugin || state === "normal") return [];
+    const c = {
+      plan,
+      items,
+      seed,
+      state,
+      rng: createRng(seed, plugin.seedKey ?? "state:" + state),
+      ctx,
+      kit: placementKit,
+      catalog: registries().CATALOG,
+      wallTopHeights: registries().WALL_TOP_HEIGHTS
+    };
+    return plugin.apply(c);
+  }
+  var loc = (key, locale, ns = "labels", vars) => key ? translate(ns, key, locale, vars) : key;
+  function generate(template, options) {
+    const tpl = templateOf(template);
+    const o = options || {};
+    const seed = o.seed == null ? 1 : o.seed;
+    const locale = o.locale || "en";
+    let op = Object.assign({}, o, { seed });
+    const zone = resolveZone(o.zone);
+    const adjustments = [];
+    if (zone) op = clampOptionsToZone(tpl, op, zone, adjustments);
+    const plan = buildPlan(tpl, op.w, op.d, op, { zone, adjustments });
+    const all = resolveSlots(plan);
+    const items = [];
+    const missing = [];
+    for (const room of plan.rooms.concat(plan.zones)) {
+      const sl = all.filter((s) => s.room === room.id && s.floor === room.floor);
+      const r = fillRoom(plan, room, sl, createRng(seed, STREAM.roomPrefix + (room.seedKey ?? registries().SEED_KEYS.rooms[room.id] ?? room.id)));
+      items.push(...r.items);
+      missing.push(...r.missing);
+    }
+    const ctx = runPostProcess(plan, items, seed);
+    const state = pickState(o.state, seed);
+    const stateItemsAll = applyState(plan, items, ctx, seed, state);
+    const colors2 = palette({ seed, style: plan.style, state });
+    const strip = (m) => {
+      const x = {};
+      for (const k of Object.keys(m)) if (k[0] !== "_" && k !== "colorSpec") x[k] = m[k];
+      return x;
+    };
+    const L = plan.lot;
+    const lot = L ? {
+      rect: L.rect.map(r2),
+      setback: r2(L.setback),
+      backyard: r2(L.backyard),
+      sideYard: L.sideYard,
+      style: L.style,
+      pool: L.pool,
+      zones: plan.zones.map((z) => ({ id: z.id, type: z.type, label: z.label, name: loc(z.label, locale), parts: z.parts, ground: z.ground })),
+      perimeter: L.perimeter.map((s) => Object.assign({ color: "wall" }, s)),
+      gates: plan.gates.map((g) => ({ id: g.id, type: g.type, model: g.model, u: g.u, v: g.v, axis: g.axis, width: g.width, height: g.height, side: g.side, to: g.to, material: g.material, open: !!g.open, color: "gate" })),
+      paths: plan.paths.map((c) => ({ id: c.id, type: c.type, from: c.from, to: c.to, width: c.width, rects: c.rects, points: c.points }))
+    } : null;
+    const facade = Object.assign({}, plan.facade, {
+      color: { name: loc(colors2.meta.base, locale, "facadeColors"), key: colors2.meta.base, hex: hexString(colors2.facade) },
+      roles: { facade: "facade", detail: "facade_detail", roof: "roof", wall: "wall", gate: "gate" }
+    });
+    const itemsOut = items.map((m) => {
+      const out = strip(m);
+      out.color = colorOf(m, seed);
+      return out;
+    });
+    const stateItemsOut = stateItemsAll.map((m) => {
+      const out = strip(m);
+      if (m.category) out.color = colorOf(m, seed);
+      return out;
+    });
+    const base = {
+      template: tpl.id,
+      name: translate("templates", tpl.id, locale),
+      use: useOf(tpl),
+      seed,
+      style: plan.style,
+      state,
+      w: plan.w,
+      d: plan.d,
+      floors: plan.floors.map((f) => ({ index: f.index, label: f.name, name: f.number != null ? translate("labels", "floor_n", locale, { n: f.number }) : loc(f.name, locale), number: f.number, y0: f.y0, ceiling: f.ceiling })),
+      rooms: plan.rooms.map((c) => ({
+        id: c.id,
+        type: c.type,
+        label: c.label,
+        name: loc(c.label, locale),
+        floor: c.floor,
+        u0: c.parts[0][0],
+        v0: c.parts[0][1],
+        u1: c.parts[0][2],
+        v1: c.parts[0][3],
+        parts: c.parts,
+        link: c.link,
+        ceiling: c.ceiling || plan.floors[c.floor].ceiling,
+        color: { wall: "wall_" + c.type, floor: "floor_" + c.type }
+      })),
+      walls: plan.walls,
+      doors: plan.doors,
+      windows: plan.windows,
+      openPairs: [].concat(...Object.values(plan.openPairs)),
+      facade,
+      lot,
+      items: itemsOut,
+      stateItems: stateItemsOut,
+      colors: colors2,
+      building: tpl.building ? tpl.building(plan.w, plan.d, op) : null,
+      missing
+    };
+    if (tpl.singleFloor) base.floorNumber = op.floor || 3;
+    const result = Object.assign(base, { partyWalls: tpl.partyWalls || [] });
+    if (plan.config) result.config = plan.config;
+    runResultExtensions(plan, result, seed, op);
+    if (zone) {
+      const report = { zone: zone.id, adjustments, violations: checkLot(zone, lot, Object.assign({}, result, { rooms: plan.rooms })) };
+      result.zoning = report;
+    }
+    return result;
+  }
+  var isSolid = (m) => !m.flat && !m.on && (!m.decor || m.mount === "floor");
+  function validate(result, options) {
+    const locale = options?.locale || result.locale || "en";
+    const t = (key, vars) => translate("messages", key, locale, vars);
+    const errors = [];
+    const solids = result.items.filter(isSolid);
+    for (let i = 0; i < solids.length; i++)
+      for (let j = i + 1; j < solids.length; j++)
+        if (solids[i].floor === solids[j].floor && !solids[i].barricade && !solids[j].barricade && overlaps(solids[i].aabb, solids[j].aabb, 0.011)) errors.push(t("overlap", { a: solids[i].id, b: solids[j].id }));
+    for (const m of solids) {
+      if (m.barricade) continue;
+      for (const p of result.doors) if (p.floor === (m.outdoor ? 0 : m.floor) && p.zones.some((z) => overlaps(m.aabb, z, 0.011))) errors.push(t("door_blocked", { id: m.id }));
+      if (result.lot) {
+        for (const g of result.lot.gates) if (m.outdoor && openingZones(g.u, g.v, "u", g.width, DOOR_CLEARANCE).some((z) => overlaps(m.aabb, z, 0.011))) errors.push(t("gate_blocked", { id: m.id }));
+      }
+    }
+    for (const f of result.missing) errors.push(t("missing_required", { room: f.room, slot: f.slot }));
+    if (result.zoning) for (const v of result.zoning.violations) errors.push(t("zone_violation", { zone: result.zoning.zone, rule: v.rule, actual: v.actual, limit: v.limit }));
+    return errors;
+  }
+  function limitsOf(template, options) {
+    const tpl = templateOf(template);
+    const op = options || {};
+    return { limits: tpl.limitsFn ? tpl.limitsFn(op) : tpl.limits, defaults: tpl.defaultsFn ? tpl.defaultsFn(op) : tpl.defaults };
+  }
+  function listTemplates(locale = "en") {
+    return Object.values(registries().TEMPLATES).map((t) => {
+      const a = floorsOf(t, {});
+      return {
+        id: t.id,
+        name: translate("templates", t.id, locale),
+        use: useOf(t),
+        style: typeof t.style === "function" ? t.style({}) : t.style,
+        limits: t.limits,
+        defaults: t.defaults,
+        floors: a.length,
+        floorRange: t.floorRange || null,
+        lot: !!t.lot,
+        options: t.options || {}
+      };
+    });
   }
   function registerGroundItems() {
     const flat = { category: "ground_cover", w: 1, d: 1, h: 0, decor: true, mount: "ground", flat: true };
@@ -127,6 +2389,14 @@ var GameUrban = (() => {
       { type: "dirt", ...flat, color: { role: "dirt" } }
     ]);
   }
+  var slotKit = {
+    wall: (id, side, pos, size, cats, o) => Object.assign({ id, anchor: "wall", side, pos, size, cats }, o),
+    corner: (id, corner, size, cats, o) => Object.assign({ id, anchor: "corner", corner, size, cats }, o),
+    center: (id, fx, fz, size, cats, o) => Object.assign({ id, anchor: "center", fx, fz, size, cats }, o),
+    windowSlot: (id, size, cats, o) => Object.assign({ id, anchor: "window", size, cats }, o),
+    on: (id, parent, cats, o) => Object.assign({ id, anchor: "on", on: parent, cats }, o),
+    inside: (id, parent, cats, o) => Object.assign({ id, anchor: "inside", on: parent, cats }, o)
+  };
   var en_default = {
     labels: {
       floor_n: "Floor {n}",
@@ -321,6 +2591,82 @@ var GameUrban = (() => {
       reason_permeable_min: "\xC1rea perme\xE1vel da zona"
     }
   };
+  var version = "0.1.0";
+  function buildEngine(scope) {
+    const scoped = (fn) => ((...args) => withRegistries(scope, () => fn(...args)));
+    return {
+      version,
+      generate: scoped(generate),
+      slots: scoped(slots),
+      validate: scoped(validate),
+      palette: scoped(palette),
+      limitsOf: scoped(limitsOf),
+      listTemplates: scoped(listTemplates),
+      listStates: scoped(listStates),
+      // content registration
+      registerItem: scoped(registerItem),
+      registerItems: scoped(registerItems),
+      registerLibrary: scoped(registerLibrary),
+      registerLibraryAlias: scoped(registerLibraryAlias),
+      registerTemplate: scoped(registerTemplate),
+      registerStyle: scoped(registerStyle),
+      registerPaletteStyle: scoped(registerPaletteStyle),
+      registerRoomColors: scoped(registerRoomColors),
+      registerDecorProfile: scoped(registerDecorProfile),
+      registerPass: scoped(registerPass),
+      registerGroundOverlay: scoped(registerGroundOverlay),
+      registerWallTop: scoped(registerWallTop),
+      registerSeedKeys: scoped(registerSeedKeys),
+      registerState: scoped(registerState),
+      setStateDistribution: scoped(setStateDistribution),
+      registerLocale: scoped(registerLocale),
+      registerResultExtension: scoped(registerResultExtension),
+      registerFindsProvider: scoped(registerFindsProvider),
+      findsFor: scoped(findsFor),
+      findsAnswer: scoped(findsAnswer),
+      registerViewerLayer: scoped(registerViewerLayer),
+      viewerLayers: scope.VIEWER_LAYERS,
+      blocksWindow: scoped(blocksWindow),
+      // zoning
+      defineZone: scoped(defineZone),
+      getZone: scoped(getZone),
+      listZones: scoped(listZones),
+      checkLot: scoped(checkLot),
+      registerPermeableGround: scoped(registerPermeableGround),
+      // kits and data
+      slotKit,
+      translate: scoped(translate),
+      listLocales: scoped(listLocales),
+      templates: scope.TEMPLATES,
+      catalog: scope.CATALOG,
+      libraries: scope.LIBRARIES,
+      styles: scope.STYLES,
+      paletteStyles: scope.PALETTE_STYLES,
+      createRng,
+      mulberry32,
+      hashString,
+      overlaps,
+      windowZone,
+      openingZones,
+      color: { lstar, hex: hexString, hsl: intToHsl, HIGH_SATURATION, MIN_WALL_FLOOR_CONTRAST, MIN_FABRIC_FLOOR_CONTRAST },
+      constants: { WALL_THICKNESS, DOOR_CLEARANCE, PLAYER_RADIUS, DOOR_EDGE_CLEARANCE, WINDOW_EDGE_CLEARANCE, OVERHEAD_TOP, CAR_CLEARANCE }
+    };
+  }
+  function seedBase(scope) {
+    withRegistries(scope, () => {
+      registerGroundItems();
+      registerPermeableGround("lawn", "dirt");
+      registerLocale("en", en_default);
+      registerLocale("pt-BR", pt_BR_default);
+    });
+  }
+  var defaultEngine;
+  function defaultFloorplan() {
+    if (defaultEngine) return defaultEngine;
+    seedBase(getDefaultRegistries());
+    defaultEngine = buildEngine(getDefaultRegistries());
+    return defaultEngine;
+  }
   function createSilhouetteRandom(seed) {
     let state = seed;
     return () => {
@@ -521,10 +2867,7 @@ var GameUrban = (() => {
     }
     return b.finish({ x: p.x, z: p.z, width: w + 0.5, depth: d + 0.5, height: 4.6 });
   }
-  registerGroundItems();
-  registerPermeableGround("lawn", "dirt");
-  registerLocale("en", en_default);
-  registerLocale("pt-BR", pt_BR_default);
+  var engine = defaultFloorplan();
 
   // src/scene.ts
   var ROOT2 = -1;
@@ -537,7 +2880,7 @@ var GameUrban = (() => {
     const parts = [];
     const items = [];
     const windows = { lit: [], dark: [] };
-    const lights = options.budget ?? createLightBudget(Number.POSITIVE_INFINITY);
+    const lights = options.budget ?? createLightAllowance(Number.POSITIVE_INFINITY);
     const pick = (list) => list[Math.floor(random() * list.length)];
     const group = (x, y, z, ry = 0, parent = ROOT2) => parts.push({ shape: "group", parent, x, y, z, ry }) - 1;
     const box = (x, y, z, width, height, depth, color, o = {}) => {
@@ -838,7 +3181,7 @@ var GameUrban = (() => {
   var lerp = (a, b, t) => a + (b - a) * t;
   function fillBlock(b, cx, cz, size, minHeight, maxHeight, options = {}) {
     const placed = [];
-    const palette = options.palette ?? DEFAULT_FACADES;
+    const palette2 = options.palette ?? DEFAULT_FACADES;
     const half = (size - STREET_MARGIN) / 2;
     const k = options.k || DEFAULT_PARTITIONS;
     const lot = (size - STREET_MARGIN) / k;
@@ -864,7 +3207,7 @@ var GameUrban = (() => {
         }
         const x = cx - half + lot * (i + 0.5);
         const z = cz - half + lot * (j + 0.5);
-        const color = b.pick(palette);
+        const color = b.pick(palette2);
         placed.push((options.draw ?? drawBuilding)(b, x, z, width, depth, height, color, extra ? { ...options, ...extra } : options));
       }
     }
@@ -894,16 +3237,16 @@ var GameUrban = (() => {
     b.prism(x, 0, z, w, w * 0.7, d, color ?? colors(c).tent, -1, ry);
   }
   function drawPine(b, x, z, scale = 1, y = 0, c) {
-    const palette = colors(c);
-    b.cylinder(x, y, z, 0.12 * scale, 0.16 * scale, 1 * scale, palette.trunk);
-    const green = b.pick(palette.pines);
+    const palette2 = colors(c);
+    b.cylinder(x, y, z, 0.12 * scale, 0.16 * scale, 1 * scale, palette2.trunk);
+    const green = b.pick(palette2.pines);
     b.cone(x, y + 0.8 * scale, z, 1.1 * scale, 2.2 * scale, green);
     b.cone(x, y + 2.1 * scale, z, 0.8 * scale, 1.8 * scale, green);
   }
   function drawTree(b, x, z, scale = 1, c) {
-    const palette = colors(c);
-    b.cylinder(x, 0, z, 0.12 * scale, 0.18 * scale, 1.8 * scale, palette.trunk);
-    b.crown(x, 2.6 * scale, z, 1.3 * scale, b.pick(palette.crowns));
+    const palette2 = colors(c);
+    b.cylinder(x, 0, z, 0.12 * scale, 0.18 * scale, 1.8 * scale, palette2.trunk);
+    b.crown(x, 2.6 * scale, z, 1.3 * scale, b.pick(palette2.crowns));
   }
   function drawContainer(b, x, y, z, ry, color) {
     const group = b.group(x, y, z, ry);
@@ -911,11 +3254,11 @@ var GameUrban = (() => {
     for (let k = -2; k <= 2; k++) b.box(k * 0.5, 0, 3.04, 0.06, 2.6, 0.04, 1710618, { parent: group });
   }
   function drawWatchtower(b, x, z, searchlight = false, c) {
-    const palette = colors(c).watchtower;
-    for (const a of [-1, 1]) for (const d of [-1, 1]) b.box(x + a * 1.2, 0, z + d * 1.2, 0.25, 7, 0.25, palette.leg);
-    b.box(x, 7, z, 3.2, 1.2, 3.2, palette.cabin);
-    b.box(x, 8.2, z, 3.6, 0.15, 3.6, palette.deck);
-    for (const side of [-1.5, 1.5]) b.box(x + side, 8.2, z, 0.15, 1.6, 0.15, palette.deck);
+    const palette2 = colors(c).watchtower;
+    for (const a of [-1, 1]) for (const d of [-1, 1]) b.box(x + a * 1.2, 0, z + d * 1.2, 0.25, 7, 0.25, palette2.leg);
+    b.box(x, 7, z, 3.2, 1.2, 3.2, palette2.cabin);
+    b.box(x, 8.2, z, 3.6, 0.15, 3.6, palette2.deck);
+    for (const side of [-1.5, 1.5]) b.box(x + side, 8.2, z, 0.15, 1.6, 0.15, palette2.deck);
     if (searchlight) b.spot({ x, y: 9, z, color: 15134463, intensity: 2.4, distance: 70, decay: 1.2, angle: 0.35, penumbra: 0.5, target: { x: x + 20, y: 0, z: z + 20 }, sweep: { speed: 0.5, radius: 25 } });
   }
   function drawSandbags(b, x, z, length, along, rows = 3, c) {
@@ -935,34 +3278,6 @@ var GameUrban = (() => {
     b.line(points.map(([px, pz]) => [px, y, pz]), color ?? colors(c).wire);
   }
 
-  // ../game-contracts/dist/index.js
-  var UNSAFE_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
-  var isPlainObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value) && Object.getPrototypeOf(value) === Object.prototype;
-  var deepMerge = (base, patch) => {
-    if (!patch) return base;
-    const result = { ...base };
-    for (const [key, value] of Object.entries(patch)) {
-      if (value === void 0 || UNSAFE_KEYS.has(key)) continue;
-      const current = result[key];
-      result[key] = isPlainObject(current) && isPlainObject(value) ? deepMerge(current, value) : value;
-    }
-    return result;
-  };
-  var mergeById = (shipped, extra) => {
-    const entries = /* @__PURE__ */ new Map();
-    for (const entry of [...shipped, ...extra ?? []]) entries.set(entry.id, entry);
-    return entries;
-  };
-  var applyPatches = (entries, patches) => {
-    for (const [id, patch] of Object.entries(patches ?? {})) {
-      const entry = entries.get(id);
-      if (entry) entries.set(id, deepMerge(entry, patch));
-    }
-  };
-  var removeIds = (entries, ids) => {
-    for (const id of ids ?? []) entries.delete(id);
-  };
-
   // src/neighbourhoods/houses.ts
   var DEFAULT_WIDTH = 8;
   var DEFAULT_DEPTH = 10;
@@ -1701,7 +4016,7 @@ var GameUrban = (() => {
       const plan = typeof planOrId === "string" ? plans.resolve(planOrId) : resolvePlan(planOrId);
       const locale = options.locale ?? DEFAULT_LOCALE2;
       const cap = Math.max(0, options.maxFloors ?? maxFloors);
-      const clamp2 = (n) => Math.min(cap, Math.max(0, n));
+      const clamp3 = (n) => Math.min(cap, Math.max(0, n));
       const districts = plan.districts.map((d) => {
         const kind = kinds.get(d.kind);
         const kindText = text(kind.text, locale);
@@ -1715,7 +4030,7 @@ var GameUrban = (() => {
           color: kind.color,
           zone: kind.zone,
           pattern: kind.pattern,
-          floors: [clamp2(lo), clamp2(hi)],
+          floors: [clamp3(lo), clamp3(hi)],
           uses: d.uses ?? kind.uses,
           block: kind.block
         };
@@ -1798,10 +4113,10 @@ var GameUrban = (() => {
   }
 
   // src/terrain/math.ts
-  var clamp = (v, a, b) => v < a ? a : v > b ? b : v;
+  var clamp2 = (v, a, b) => v < a ? a : v > b ? b : v;
   var lerp2 = (a, b, t) => a + (b - a) * t;
   var smoothstep = (a, b, x) => {
-    const t = clamp((x - a) / (b - a), 0, 1);
+    const t = clamp2((x - a) / (b - a), 0, 1);
     return t * t * (3 - 2 * t);
   };
   var hash2 = (a, b) => {
@@ -1815,7 +4130,7 @@ var GameUrban = (() => {
       const [bx, by] = points[index + 1];
       const dx = bx - ax;
       const dy = by - ay;
-      const t = clamp(((px - ax) * dx + (py - ay) * dy) / (dx * dx + dy * dy), 0, 1);
+      const t = clamp2(((px - ax) * dx + (py - ay) * dy) / (dx * dx + dy * dy), 0, 1);
       const d = Math.hypot(px - ax - t * dx, py - ay - t * dy);
       if (d < best) best = d;
     }
@@ -1924,7 +4239,8 @@ var GameUrban = (() => {
   }
 
   // src/kit.ts
-  var DEFAULT_LIGHT_BUDGET = 16;
+  var DEFAULT_LIGHT_ALLOWANCE = 16;
+  var DEFAULT_LIGHT_BUDGET = DEFAULT_LIGHT_ALLOWANCE;
   var DEFAULT_URBAN_SEED = 7;
   function createUrban(options = {}) {
     const entries = mergeById(DEFAULT_POLES, options.packs?.poles);
@@ -1935,7 +4251,7 @@ var GameUrban = (() => {
     applyPatches(patterns, options.patch?.neighbourhoods);
     removeIds(patterns, options.remove?.neighbourhoods);
     const composers = { ...COMPOSERS, ...options.composers };
-    const lightBudget = options.lights?.budget ?? DEFAULT_LIGHT_BUDGET;
+    const lightBudget = options.lights?.budget ?? DEFAULT_LIGHT_ALLOWANCE;
     const facades = options.facades ?? DEFAULT_FACADES;
     const propColors = { ...DEFAULT_PROP_COLORS, ...options.props };
     const towers = options.towers ? options.towers === true ? {} : options.towers : null;
@@ -1977,7 +4293,7 @@ var GameUrban = (() => {
         wires: (b, points, y, color) => drawWires(b, points, y, color, propColors)
       }
     };
-    const builder = (o = {}) => createUrbanBuilder(o.random ?? createSilhouetteRandom(o.seed ?? DEFAULT_URBAN_SEED), { budget: createLightBudget(o.budget ?? lightBudget) });
+    const builder = (o = {}) => createUrbanBuilder(o.random ?? createSilhouetteRandom(o.seed ?? DEFAULT_URBAN_SEED), { budget: createLightAllowance(o.budget ?? lightBudget) });
     const neighbourhoods = {
       ids: () => [...patterns.keys()],
       get(id) {
@@ -6898,7 +9214,7 @@ var GameUrban = (() => {
     const THREE = kit.THREE;
     const trl = fx.t;
     const lbl = fx.label;
-    const V3 = kit.V3, PI = Math.PI, MT = kit.materials, CM = kit.makeMaterial, G = kit.geo, profX = kit.profX, halfAt = kit.halfAt, clamp2 = kit.clamp, smooth = kit.smooth;
+    const V3 = kit.V3, PI = Math.PI, MT = kit.materials, CM = kit.makeMaterial, G = kit.geo, profX = kit.profX, halfAt = kit.halfAt, clamp3 = kit.clamp, smooth = kit.smooth;
     const GLOSS = CM("#07080a", { roughness: 0.18, metalness: 0.5 });
     const ALLOY = CM("#b9bec2", { metalness: 0.75, roughness: 0.3 });
     const ALLOYD = CM("#3a3e42", { metalness: 0.6, roughness: 0.35 });
@@ -6912,7 +9228,7 @@ var GameUrban = (() => {
           const a = (y - o.ys) / (o.belt - o.ys);
           return o.kt * a * a;
         }
-        const b = clamp2((o.ys - y) / (o.ys - o.yb), 0, 1.25);
+        const b = clamp3((o.ys - y) / (o.ys - o.yb), 0, 1.25);
         return o.kb * b * b;
       }
       const f = function(x, y, z) {
@@ -6992,13 +9308,13 @@ var GameUrban = (() => {
       });
     }
     function roofAt(gh, x) {
-      const rR = gh.roofR || gh.roof, t = clamp2((x - gh.rt) / (gh.ft - gh.rt), 0, 1);
+      const rR = gh.roofR || gh.roof, t = clamp3((x - gh.rt) / (gh.ft - gh.rt), 0, 1);
       return rR + (gh.roof - rR) * t + (gh.crown || 0) * 4 * t * (1 - t);
     }
     function windows(gh) {
       const inn = 0.07, rise = gh.rise || 0;
       function ybAt(x) {
-        return gh.belt + 0.035 + rise * clamp2((gh.fb - x) / (gh.fb - gh.rb), 0, 1);
+        return gh.belt + 0.035 + rise * clamp3((gh.fb - x) / (gh.fb - gh.rb), 0, 1);
       }
       function lx(x0, x1, y, top) {
         return x0 + (x1 - x0) * (y - gh.belt) / (top - gh.belt);
@@ -7201,7 +9517,7 @@ var GameUrban = (() => {
       }
       const G2 = { P, N, nu, nv, y0: o.y0, y1: o.y1, len: tot * (full ? 2 : 1), E, sd };
       G2.at = function(u, y) {
-        const fi = clamp2(u, 0, 1) * nu, fj = clamp2((y - o.y0) / (o.y1 - o.y0), 0, 1) * nv, i0 = Math.min(nu - 1, Math.floor(fi)), j0 = Math.min(nv - 1, Math.floor(fj)), a = fi - i0, b = fj - j0;
+        const fi = clamp3(u, 0, 1) * nu, fj = clamp3((y - o.y0) / (o.y1 - o.y0), 0, 1) * nv, i0 = Math.min(nu - 1, Math.floor(fi)), j0 = Math.min(nv - 1, Math.floor(fj)), a = fi - i0, b = fj - j0;
         function L(M) {
           return M[i0][j0].clone().multiplyScalar((1 - a) * (1 - b)).addScaledVector(M[i0 + 1][j0], a * (1 - b)).addScaledVector(M[i0][j0 + 1], (1 - a) * b).addScaledVector(M[i0 + 1][j0 + 1], a * b);
         }
@@ -7338,10 +9654,10 @@ var GameUrban = (() => {
       m.rotation.order = "XYZ";
       return m;
     }
-    function regLight(c, kind, label, inner, lens, pos) {
-      const L = { group: null, inner, lens, kind, tint: kind === "headlight" ? "clear" : "red", broken: false };
+    function regLight(c, kind, label, inner2, lens, pos) {
+      const L = { group: null, inner: inner2, lens, kind, tint: kind === "headlight" ? "clear" : "red", broken: false };
       c.lights.push(L);
-      const pt = c.part(kind, label, inner[0], pos, 0.8);
+      const pt = c.part(kind, label, inner2[0], pos, 0.8);
       pt.light = L;
       return L;
     }
@@ -7373,7 +9689,7 @@ var GameUrban = (() => {
           du: 0.018,
           dv: 0.012
         });
-        const pu = pad / Gd.len, inner = [], lens = [];
+        const pu = pad / Gd.len, inner2 = [], lens = [];
         const yb = function(u) {
           return sh(u)[0];
         }, yt = function(u) {
@@ -7398,13 +9714,13 @@ var GameUrban = (() => {
           ring.castShadow = false;
           const b = onSurf(c.sphere(rad, MT.head, 0, 0, 0, 1, 0.55, 1), s, 0.01);
           b.castShadow = false;
-          inner.push(b);
+          inner2.push(b);
         });
         (o.drl || []).forEach(function(d) {
-          inner.push(skin(c, Gd, d.mat || DRL, { u0: d.u0, u1: d.u1, yb: d.yb, yt: d.yt, off: 95e-4, nv: 2 }));
+          inner2.push(skin(c, Gd, d.mat || DRL, { u0: d.u0, u1: d.u1, yb: d.yb, yt: d.yt, off: 95e-4, nv: 2 }));
         });
         (o.amber || []).forEach(function(d) {
-          inner.push(skin(c, Gd, MT.amber, { u0: d.u0, u1: d.u1, yb: d.yb, yt: d.yt, off: 9e-3, nv: 2 }));
+          inner2.push(skin(c, Gd, MT.amber, { u0: d.u0, u1: d.u1, yb: d.yb, yt: d.yt, off: 9e-3, nv: 2 }));
         });
         const ln = skin(c, Gd, MT.lens, {
           yb: function(u) {
@@ -7418,9 +9734,9 @@ var GameUrban = (() => {
           order: 3
         });
         lens.push(ln);
-        if (!inner.length) inner.push(ln);
+        if (!inner2.length) inner2.push(ln);
         const cs = Gd.at(0.5, (rg[0] + rg[1]) / 2).p;
-        regLight(c, "headlight", o.label || (sd > 0 ? trl("labels.right_headlight") : trl("labels.left_headlight")), inner, lens, cs);
+        regLight(c, "headlight", o.label || (sd > 0 ? trl("labels.right_headlight") : trl("labels.left_headlight")), inner2, lens, cs);
         return Gd;
       };
       K.tail = function(sd, o) {
@@ -7434,7 +9750,7 @@ var GameUrban = (() => {
           du: 0.018,
           dv: 0.012
         });
-        const pu = pad / Gd.len, inner = [], lens = [], yb = function(u) {
+        const pu = pad / Gd.len, inner2 = [], lens = [], yb = function(u) {
           return sh(u)[0];
         }, yt = function(u) {
           return sh(u)[1];
@@ -7449,15 +9765,15 @@ var GameUrban = (() => {
           off: 3e-3,
           nv: 4
         });
-        inner.push(skin(c, Gd, o.main || TAILD, { u0: pu, u1: 1 - pu, yb, yt, off: 6e-3, nv: 4 }));
+        inner2.push(skin(c, Gd, o.main || TAILD, { u0: pu, u1: 1 - pu, yb, yt, off: 6e-3, nv: 4 }));
         (o.hi || []).forEach(function(d) {
-          inner.push(skin(c, Gd, d.mat || TAILHI, { u0: d.u0, u1: d.u1, yb: d.yb, yt: d.yt, off: 9e-3, nv: 2 }));
+          inner2.push(skin(c, Gd, d.mat || TAILHI, { u0: d.u0, u1: d.u1, yb: d.yb, yt: d.yt, off: 9e-3, nv: 2 }));
         });
         (o.rev || []).forEach(function(d) {
-          inner.push(skin(c, Gd, MT.rev, { u0: d.u0, u1: d.u1, yb: d.yb, yt: d.yt, off: 85e-4, nv: 2 }));
+          inner2.push(skin(c, Gd, MT.rev, { u0: d.u0, u1: d.u1, yb: d.yb, yt: d.yt, off: 85e-4, nv: 2 }));
         });
         (o.amber || []).forEach(function(d) {
-          inner.push(skin(c, Gd, MT.amber, { u0: d.u0, u1: d.u1, yb: d.yb, yt: d.yt, off: 85e-4, nv: 2 }));
+          inner2.push(skin(c, Gd, MT.amber, { u0: d.u0, u1: d.u1, yb: d.yb, yt: d.yt, off: 85e-4, nv: 2 }));
         });
         lens.push(
           skin(c, Gd, o.lens || MT.lensRed, {
@@ -7476,7 +9792,7 @@ var GameUrban = (() => {
           c,
           "taillight",
           o.label || (sd > 0 ? trl("labels.right_taillight") : trl("labels.left_taillight")),
-          inner,
+          inner2,
           lens,
           Gd.at(0.4, (rg[0] + rg[1]) / 2).p
         );
@@ -7781,7 +10097,7 @@ var GameUrban = (() => {
           c.roundBox(x1 - x0, 0.08, 0.035, 0.015, MT.trim, (x0 + x1) / 2, by + 0.05, sd * (hw - 8e-3));
           if (s.clad)
             s.arches.forEach(function(a) {
-              const a0 = Math.asin(clamp2((by - a[1]) / a[2], -1, 1)), tor = c.add(new THREE.TorusGeometry(a[2] + 0.02, 0.035, 6, 26, PI - 2 * a0), MT.trim, a[0], a[1], sd * (hw - 0.01));
+              const a0 = Math.asin(clamp3((by - a[1]) / a[2], -1, 1)), tor = c.add(new THREE.TorusGeometry(a[2] + 0.02, 0.035, 6, 26, PI - 2 * a0), MT.trim, a[0], a[1], sd * (hw - 0.01));
               tor.rotation.z = a0;
               tor.scale.z = 0.8;
             });
@@ -7912,7 +10228,7 @@ var GameUrban = (() => {
       c.cylinder(0.06, 0.06, 0.012, MT.head, x + 0.055, y, z, "x");
     }
     function sm(t) {
-      t = clamp2(t, 0, 1);
+      t = clamp3(t, 0, 1);
       return t * t * (3 - 2 * t);
     }
     function sideGrid(S, sd, o) {
@@ -7929,7 +10245,7 @@ var GameUrban = (() => {
       }
       const G2 = { P, N, nu, nv, y0: o.y0, y1: o.y1, len: Math.abs(o.x1 - o.x0) };
       G2.at = function(u, y) {
-        const fi = clamp2(u, 0, 1) * nu, fj = clamp2((y - o.y0) / (o.y1 - o.y0), 0, 1) * nv, i0 = Math.min(nu - 1, Math.floor(fi)), j0 = Math.min(nv - 1, Math.floor(fj)), a = fi - i0, b = fj - j0;
+        const fi = clamp3(u, 0, 1) * nu, fj = clamp3((y - o.y0) / (o.y1 - o.y0), 0, 1) * nv, i0 = Math.min(nu - 1, Math.floor(fi)), j0 = Math.min(nv - 1, Math.floor(fj)), a = fi - i0, b = fj - j0;
         function L(M) {
           return M[i0][j0].clone().multiplyScalar((1 - a) * (1 - b)).addScaledVector(M[i0 + 1][j0], a * (1 - b)).addScaledVector(M[i0][j0 + 1], (1 - a) * b).addScaledVector(M[i0 + 1][j0 + 1], a * b);
         }
@@ -9657,7 +11973,7 @@ var GameUrban = (() => {
             const g = K.grid(1, 0, { z1: 0.66, y0: 0.27, y1: 0.61, du: 0.03, dv: 0.03 }), zt = 0.6, zb = 0.43, yB0 = 0.3, yT = 0.585;
             const gyb = function(u) {
               const z = Math.abs(g.zu(u));
-              return z <= zb ? yB0 : yB0 + (yT - 0.02 - yB0) * clamp2((z - zb) / (zt - zb), 0, 1);
+              return z <= zb ? yB0 : yB0 + (yT - 0.02 - yB0) * clamp3((z - zb) / (zt - zb), 0, 1);
             };
             K.skin(g, grilleMat("mesh"), { u0: g.uz(-zt), u1: g.uz(zt), yb: gyb, yt: yT, off: 0.022, tile: 0.05, nv: 6 });
             outline(c2, g, { u0: g.uz(-zt), u1: g.uz(zt), yb: gyb, yt: yT }, 0.012, LH, 0.024);
@@ -11220,6 +13536,7 @@ var GameUrban = (() => {
         hood: true
       },
       function(c) {
+        c.meta.armor = "III";
         const f = 3.75, W = 2.32, len = 1.85, ax = 2.5, wr = 0.506, ww = 0.28, col = "#56616b";
         c.meta.bullet = true;
         c.meta.cabLength = len + 0.15;
@@ -14607,8 +16924,8 @@ var GameUrban = (() => {
         kit.steeringWheel(c, 1.5, 1.42, -0.62, { r: 0.2, tilt: 0.9, col: 0.35 });
         c.roundBox(0.35, 0.3, 0.7, 0.04, CM("#25261f"), 1.85, 1.45, -0.6);
         kit.seat(c, 0.15, fl, 0, { w: 0.5, h: 0.45, back: 0.62, lean: 0.12, mat: CM("#2f3226", { roughness: 0.9 }) });
-        for (let r2 = 0; r2 < 3; r2++)
-          c.roundBox(0.25, 0.32, 0.25, 0.03, CM("#3f4a2c", { roughness: 0.6 }), -0.7 - r2 * 0.6, roofY - 0.35, 0.68);
+        for (let r22 = 0; r22 < 3; r22++)
+          c.roundBox(0.25, 0.32, 0.25, 0.03, CM("#3f4a2c", { roughness: 0.6 }), -0.7 - r22 * 0.6, roofY - 0.35, 0.68);
         const ramp2 = new THREE.Group(), RL = 1.36, rmat = paintMat(c, col);
         ramp2.position.set(R - 0.05, 0.62, 0);
         ramp2.rotation.z = -PI / 2;
@@ -15815,7 +18132,7 @@ var GameUrban = (() => {
     const THREE = kit.THREE;
     const trl = fx.t;
     const lbl = fx.label;
-    const V3 = kit.V3, PI = Math.PI, MT = kit.materials, CM = kit.makeMaterial, G = kit.geo, profX = kit.profX, halfAt = kit.halfAt, clamp2 = kit.clamp, smooth = kit.smooth;
+    const V3 = kit.V3, PI = Math.PI, MT = kit.materials, CM = kit.makeMaterial, G = kit.geo, profX = kit.profX, halfAt = kit.halfAt, clamp3 = kit.clamp, smooth = kit.smooth;
     const GLOSS = CM("#07080a", { roughness: 0.18, metalness: 0.5 });
     const ALLOY = CM("#b9bec2", { metalness: 0.75, roughness: 0.3 });
     const ALLOYD = CM("#3a3e42", { metalness: 0.6, roughness: 0.35 });
@@ -15834,7 +18151,7 @@ var GameUrban = (() => {
           const a = (y - o.ys) / (o.belt - o.ys);
           return o.kt * a * a;
         }
-        const b = clamp2((o.ys - y) / (o.ys - o.yb), 0, 1.25);
+        const b = clamp3((o.ys - y) / (o.ys - o.yb), 0, 1.25);
         return o.kb * b * b;
       }
       const f = function(x, y, z) {
@@ -16014,13 +18331,13 @@ var GameUrban = (() => {
       return L;
     }
     function roofAt(gh, x) {
-      const rR = gh.roofR || gh.roof, t = clamp2((x - gh.rt) / (gh.ft - gh.rt), 0, 1);
+      const rR = gh.roofR || gh.roof, t = clamp3((x - gh.rt) / (gh.ft - gh.rt), 0, 1);
       return rR + (gh.roof - rR) * t + (gh.crown || 0) * 4 * t * (1 - t);
     }
     function windows(gh) {
       const inn = 0.07, rise = gh.rise || 0;
       function ybAt(x) {
-        return gh.belt + 0.035 + rise * clamp2((gh.fb - x) / (gh.fb - gh.rb), 0, 1);
+        return gh.belt + 0.035 + rise * clamp3((gh.fb - x) / (gh.fb - gh.rb), 0, 1);
       }
       function lx(x0, x1, y, top) {
         return x0 + (x1 - x0) * (y - gh.belt) / (top - gh.belt);
@@ -16231,7 +18548,7 @@ var GameUrban = (() => {
       }
       const G2 = { P, N, nu, nv, y0: o.y0, y1: o.y1, len: tot * (full ? 2 : 1), E, sd };
       G2.at = function(u, y) {
-        const fi = clamp2(u, 0, 1) * nu, fj = clamp2((y - o.y0) / (o.y1 - o.y0), 0, 1) * nv, i0 = Math.min(nu - 1, Math.floor(fi)), j0 = Math.min(nv - 1, Math.floor(fj)), a = fi - i0, b = fj - j0;
+        const fi = clamp3(u, 0, 1) * nu, fj = clamp3((y - o.y0) / (o.y1 - o.y0), 0, 1) * nv, i0 = Math.min(nu - 1, Math.floor(fi)), j0 = Math.min(nv - 1, Math.floor(fj)), a = fi - i0, b = fj - j0;
         function L(M) {
           return M[i0][j0].clone().multiplyScalar((1 - a) * (1 - b)).addScaledVector(M[i0 + 1][j0], a * (1 - b)).addScaledVector(M[i0][j0 + 1], (1 - a) * b).addScaledVector(M[i0 + 1][j0 + 1], a * b);
         }
@@ -16368,10 +18685,10 @@ var GameUrban = (() => {
       m.rotation.order = "XYZ";
       return m;
     }
-    function regLight(c, kind, label, inner, lens, pos) {
-      const L = { group: null, inner, lens, kind, tint: kind === "headlight" ? "clear" : "red", broken: false };
+    function regLight(c, kind, label, inner2, lens, pos) {
+      const L = { group: null, inner: inner2, lens, kind, tint: kind === "headlight" ? "clear" : "red", broken: false };
       c.lights.push(L);
-      const pt = c.part(kind, label, inner[0], pos, 0.8);
+      const pt = c.part(kind, label, inner2[0], pos, 0.8);
       pt.light = L;
       return L;
     }
@@ -16403,7 +18720,7 @@ var GameUrban = (() => {
           du: 0.018,
           dv: 0.012
         });
-        const pu = pad / Gd.len, inner = [], lens = [];
+        const pu = pad / Gd.len, inner2 = [], lens = [];
         const yb = function(u) {
           return sh(u)[0];
         }, yt = function(u) {
@@ -16428,13 +18745,13 @@ var GameUrban = (() => {
           ring.castShadow = false;
           const b = onSurf(c.sphere(rad, MT.head, 0, 0, 0, 1, 0.55, 1), s, 0.01);
           b.castShadow = false;
-          inner.push(b);
+          inner2.push(b);
         });
         (o.drl || []).forEach(function(d) {
-          inner.push(skin(c, Gd, d.mat || DRL, { u0: d.u0, u1: d.u1, yb: d.yb, yt: d.yt, off: 95e-4, nv: 2 }));
+          inner2.push(skin(c, Gd, d.mat || DRL, { u0: d.u0, u1: d.u1, yb: d.yb, yt: d.yt, off: 95e-4, nv: 2 }));
         });
         (o.amber || []).forEach(function(d) {
-          inner.push(skin(c, Gd, MT.amber, { u0: d.u0, u1: d.u1, yb: d.yb, yt: d.yt, off: 9e-3, nv: 2 }));
+          inner2.push(skin(c, Gd, MT.amber, { u0: d.u0, u1: d.u1, yb: d.yb, yt: d.yt, off: 9e-3, nv: 2 }));
         });
         const ln = skin(c, Gd, MT.lens, {
           yb: function(u) {
@@ -16448,9 +18765,9 @@ var GameUrban = (() => {
           order: 3
         });
         lens.push(ln);
-        if (!inner.length) inner.push(ln);
+        if (!inner2.length) inner2.push(ln);
         const cs = Gd.at(0.5, (rg[0] + rg[1]) / 2).p;
-        regLight(c, "headlight", o.label || (sd > 0 ? trl("labels.right_headlight") : trl("labels.left_headlight")), inner, lens, cs);
+        regLight(c, "headlight", o.label || (sd > 0 ? trl("labels.right_headlight") : trl("labels.left_headlight")), inner2, lens, cs);
         return Gd;
       };
       K.tail = function(sd, o) {
@@ -16464,7 +18781,7 @@ var GameUrban = (() => {
           du: 0.018,
           dv: 0.012
         });
-        const pu = pad / Gd.len, inner = [], lens = [], yb = function(u) {
+        const pu = pad / Gd.len, inner2 = [], lens = [], yb = function(u) {
           return sh(u)[0];
         }, yt = function(u) {
           return sh(u)[1];
@@ -16479,15 +18796,15 @@ var GameUrban = (() => {
           off: 3e-3,
           nv: 4
         });
-        inner.push(skin(c, Gd, o.main || TAILD, { u0: pu, u1: 1 - pu, yb, yt, off: 6e-3, nv: 4 }));
+        inner2.push(skin(c, Gd, o.main || TAILD, { u0: pu, u1: 1 - pu, yb, yt, off: 6e-3, nv: 4 }));
         (o.hi || []).forEach(function(d) {
-          inner.push(skin(c, Gd, d.mat || TAILHI, { u0: d.u0, u1: d.u1, yb: d.yb, yt: d.yt, off: 9e-3, nv: 2 }));
+          inner2.push(skin(c, Gd, d.mat || TAILHI, { u0: d.u0, u1: d.u1, yb: d.yb, yt: d.yt, off: 9e-3, nv: 2 }));
         });
         (o.rev || []).forEach(function(d) {
-          inner.push(skin(c, Gd, MT.rev, { u0: d.u0, u1: d.u1, yb: d.yb, yt: d.yt, off: 85e-4, nv: 2 }));
+          inner2.push(skin(c, Gd, MT.rev, { u0: d.u0, u1: d.u1, yb: d.yb, yt: d.yt, off: 85e-4, nv: 2 }));
         });
         (o.amber || []).forEach(function(d) {
-          inner.push(skin(c, Gd, MT.amber, { u0: d.u0, u1: d.u1, yb: d.yb, yt: d.yt, off: 85e-4, nv: 2 }));
+          inner2.push(skin(c, Gd, MT.amber, { u0: d.u0, u1: d.u1, yb: d.yb, yt: d.yt, off: 85e-4, nv: 2 }));
         });
         lens.push(
           skin(c, Gd, o.lens || MT.lensRed, {
@@ -16506,7 +18823,7 @@ var GameUrban = (() => {
           c,
           "taillight",
           o.label || (sd > 0 ? trl("labels.right_taillight") : trl("labels.left_taillight")),
-          inner,
+          inner2,
           lens,
           Gd.at(0.4, (rg[0] + rg[1]) / 2).p
         );
@@ -16792,7 +19109,7 @@ var GameUrban = (() => {
           c.roundBox(x1 - x0, 0.08, 0.035, 0.015, MT.trim, (x0 + x1) / 2, by + 0.05, sd * (hw - 8e-3));
           if (s.clad)
             s.arches.forEach(function(a) {
-              const a0 = Math.asin(clamp2((by - a[1]) / a[2], -1, 1)), tor = c.add(new THREE.TorusGeometry(a[2] + 0.02, 0.035, 6, 26, PI - 2 * a0), MT.trim, a[0], a[1], sd * (hw - 0.01));
+              const a0 = Math.asin(clamp3((by - a[1]) / a[2], -1, 1)), tor = c.add(new THREE.TorusGeometry(a[2] + 0.02, 0.035, 6, 26, PI - 2 * a0), MT.trim, a[0], a[1], sd * (hw - 0.01));
               tor.rotation.z = a0;
               tor.scale.z = 0.8;
             });
@@ -16913,7 +19230,7 @@ var GameUrban = (() => {
       c.cylinder(0.06, 0.06, 0.012, MT.head, x + 0.055, y, z, "x");
     }
     function sm(t) {
-      t = clamp2(t, 0, 1);
+      t = clamp3(t, 0, 1);
       return t * t * (3 - 2 * t);
     }
     function sideGrid(S, sd, o) {
@@ -16930,7 +19247,7 @@ var GameUrban = (() => {
       }
       const G2 = { P, N, nu, nv, y0: o.y0, y1: o.y1, len: Math.abs(o.x1 - o.x0) };
       G2.at = function(u, y) {
-        const fi = clamp2(u, 0, 1) * nu, fj = clamp2((y - o.y0) / (o.y1 - o.y0), 0, 1) * nv, i0 = Math.min(nu - 1, Math.floor(fi)), j0 = Math.min(nv - 1, Math.floor(fj)), a = fi - i0, b = fj - j0;
+        const fi = clamp3(u, 0, 1) * nu, fj = clamp3((y - o.y0) / (o.y1 - o.y0), 0, 1) * nv, i0 = Math.min(nu - 1, Math.floor(fi)), j0 = Math.min(nv - 1, Math.floor(fj)), a = fi - i0, b = fj - j0;
         function L(M) {
           return M[i0][j0].clone().multiplyScalar((1 - a) * (1 - b)).addScaledVector(M[i0 + 1][j0], a * (1 - b)).addScaledVector(M[i0][j0 + 1], (1 - a) * b).addScaledVector(M[i0 + 1][j0 + 1], a * b);
         }
@@ -17089,7 +19406,7 @@ var GameUrban = (() => {
       return function(c, I) {
         const gh = I.gh, col = c.meta.color;
         function yb(x) {
-          return gh.belt + 0.035 + (gh.rise || 0) * clamp2((gh.fb - x) / (gh.fb - gh.rb), 0, 1);
+          return gh.belt + 0.035 + (gh.rise || 0) * clamp3((gh.fb - x) / (gh.fb - gh.rb), 0, 1);
         }
         ;
         [1, -1].forEach(function(sd) {
@@ -19960,7 +22277,7 @@ var GameUrban = (() => {
             return n.y > 0.3 && ce.x > 0.9 && ce.y > 0.6;
           },
           sdf: function(x, y, z) {
-            const t = clamp2((x - 1.17) / 0.5, 0, 1);
+            const t = clamp3((x - 1.17) / 0.5, 0, 1);
             return Math.max(0.94 - x, x - 1.69, Math.abs(z) - (0.44 - 0.16 * t * t));
           }
         });
@@ -23958,7 +26275,7 @@ var GameUrban = (() => {
     const THREE = kit.THREE;
     const trl = fx.t;
     const lbl = fx.label;
-    const V3 = kit.V3, PI = Math.PI, MT = kit.materials, CM = kit.makeMaterial, clamp2 = kit.clamp, smooth = kit.smooth;
+    const V3 = kit.V3, PI = Math.PI, MT = kit.materials, CM = kit.makeMaterial, clamp3 = kit.clamp, smooth = kit.smooth;
     const CLAD = CM("#1a1b1d", { roughness: 0.82 }), LINER = CM("#1c1d1f", { roughness: 0.92 }), RIMDARK = CM("#2a2d30", { metalness: 0.6, roughness: 0.4 });
     const RIMSIL = CM("#b9bec2", { metalness: 0.75, roughness: 0.3 }), RIMGUN = CM("#55595d", { metalness: 0.7, roughness: 0.35 });
     function axles(WB, oF, L, dF, dR) {
@@ -23989,16 +26306,16 @@ var GameUrban = (() => {
       const m = c.meta, W = m.width, by = o.bottom != null ? o.bottom : m.clearance, top = o.top != null ? o.top : m.belt;
       const Wg = m.glasshouse && m.glasshouse.Wg || W, front = m.front, rear = m.rear;
       const tuck = o.tuck == null ? 0.045 : o.tuck, peak = o.peak || 0.45;
-      const B = o.sh != null ? o.sh : clamp2(1 - (Wg + 0.06) / W, 0, 0.06);
+      const B = o.sh != null ? o.sh : clamp3(1 - (Wg + 0.06) / W, 0, 0.06);
       const Rf = o.Rf || 0.55, Rr = o.Rr || 0.42, pf = o.pf == null ? 0.08 : o.pf, pr = o.pr == null ? 0.05 : o.pr;
       const bowF = o.bowF == null ? 0.07 : o.bowF, bowR = o.bowR == null ? 0.04 : o.bowR, Rb = o.Rb || 0.35, hw = W / 2;
       const crown = o.crown == null ? 0.045 : o.crown, xc = o.crownX != null ? o.crownX : m.glasshouse ? m.glasshouse.fb : front - 1, y0 = by + 0.55 * (top - by);
       function sc(y) {
-        const t = clamp2((y - by) / (top - by), 0, 1);
+        const t = clamp3((y - by) / (top - by), 0, 1);
         return t < peak ? 1 - tuck * Math.pow(1 - t / peak, 2) : 1 - B * Math.pow((t - peak) / (1 - peak), 2);
       }
       function F(v2) {
-        const a = smooth((v2.x - (front - Rf)) / Rf), b = smooth((rear + Rr - v2.x) / Rr), zz = clamp2(v2.z / hw, -1, 1) * clamp2(v2.z / hw, -1, 1);
+        const a = smooth((v2.x - (front - Rf)) / Rf), b = smooth((rear + Rr - v2.x) / Rr), zz = clamp3(v2.z / hw, -1, 1) * clamp3(v2.z / hw, -1, 1);
         const bf = smooth((v2.x - (front - Rb)) / Rb), br = smooth((rear + Rb - v2.x) / Rb);
         const cr = crown * (1 - zz) * smooth((v2.y - y0) / (top - y0)) * smooth((v2.x - xc) / 0.3);
         v2.x += -bowF * zz * bf + bowR * zz * br;
@@ -24075,7 +26392,7 @@ var GameUrban = (() => {
       o = o || {};
       const wd = o.w || 0.075, dp = o.d || 0.045, mat = o.mat || CLAD, out = [];
       arches.forEach(function(a) {
-        const a0 = Math.asin(clamp2((by - a[1]) / a[2], -1, 1)) - 0.02, r0 = a[2] - (o.inner == null ? 0.055 : o.inner), r1 = a[2] + wd;
+        const a0 = Math.asin(clamp3((by - a[1]) / a[2], -1, 1)) - 0.02, r0 = a[2] - (o.inner == null ? 0.055 : o.inner), r1 = a[2] + wd;
         const sh = new THREE.Shape();
         if (o.trap) {
           const yb0 = Math.sin(a0) * r1, xb0 = Math.cos(a0) * r1, top = r1 * 0.93, xt = r1 * 0.52;
@@ -24424,7 +26741,7 @@ var GameUrban = (() => {
     function roof(c, drop, x0, x1) {
       const m = c.meta, b = m.glasshouse.belt, h = m.top - b;
       function dy(x, y) {
-        const t = clamp2((y - b) / h, 0, 1);
+        const t = clamp3((y - b) / h, 0, 1);
         return t <= 0 ? 0 : drop * smooth((x0 - x) / (x0 - x1)) * t;
       }
       c.root.updateMatrixWorld(true);
@@ -25618,8 +27935,8 @@ var GameUrban = (() => {
           setOnHit(pt, function(c2, p0) {
             const o = p0.obj;
             if (o && o.userData.hung && o.parent && o.parent !== c2.vehicle) {
-              o.parent.rotation.x = clamp2(o.parent.rotation.x, -0.22, 0.22);
-              o.parent.rotation.y = clamp2(o.parent.rotation.y, -0.08, 0.08);
+              o.parent.rotation.x = clamp3(o.parent.rotation.x, -0.22, 0.22);
+              o.parent.rotation.y = clamp3(o.parent.rotation.y, -0.08, 0.08);
             }
           });
         });
@@ -26225,7 +28542,7 @@ var GameUrban = (() => {
             c2.cylinder(0.03, 0.04, 0.08, MT.chrome, sx + 2.35, fl + 0.99, -0.75);
             c2.part("fuel_tank", trl("labels.oxygen_cylinder"), null, new V3(sx + 2.35, fl + 0.5, -0.75), 0.5);
             c2.roundBox(0.04, 0.26, 0.34, 0.02, MT.screen, 0.1, 1.7, 0.5);
-            const light = c2.roundBox(
+            const lightPanel = c2.roundBox(
               2.3,
               0.02,
               W - 0.3,
@@ -26235,7 +28552,7 @@ var GameUrban = (() => {
               m.top - 0.06,
               0
             );
-            light.castShadow = false;
+            lightPanel.castShadow = false;
             m.roofItems = beaconBar;
           }
         });
@@ -26270,7 +28587,7 @@ var GameUrban = (() => {
     const shared = fx.shared;
     const trl = fx.t;
     const lbl = fx.label;
-    const V3 = kit.V3, PI = Math.PI, MT = kit.materials, CM = kit.makeMaterial, _paintCol = kit.paintColor, G = kit.geo, DS = THREE.DoubleSide, clamp2 = kit.clamp;
+    const V3 = kit.V3, PI = Math.PI, MT = kit.materials, CM = kit.makeMaterial, _paintCol = kit.paintColor, G = kit.geo, DS = THREE.DoubleSide, clamp3 = kit.clamp;
     function colorize(geo, fn) {
       const p = geo.attributes.position, col = new Float32Array(p.count * 3);
       for (let i = 0; i < p.count; i++) {
@@ -26286,7 +28603,7 @@ var GameUrban = (() => {
       return a + (b - a) * t;
     }
     function sstep(a, b, x) {
-      const t = clamp2((x - a) / (b - a), 0, 1);
+      const t = clamp3((x - a) / (b - a), 0, 1);
       return t * t * (3 - 2 * t);
     }
     function tab(T) {
@@ -26363,7 +28680,7 @@ var GameUrban = (() => {
         o,
         sec,
         t: function(x) {
-          return clamp2((x - o.x0) / o.L, 0, 1);
+          return clamp3((x - o.x0) / o.L, 0, 1);
         },
         /* half beam of the hull at height y (inside, so floors and decks do not leak) */
         half: function(x, y) {
@@ -26537,7 +28854,7 @@ var GameUrban = (() => {
         for (let i = 0, j = poly.length - 1; i < poly.length; j = i++) {
           const a = poly[i], b = poly[j];
           if (a[1] > y !== b[1] > y && x < (b[0] - a[0]) * (y - a[1]) / (b[1] - a[1]) + a[0]) inside = !inside;
-          const vx = b[0] - a[0], vy = b[1] - a[1], wx = x - a[0], wy = y - a[1], t = clamp2((wx * vx + wy * vy) / (vx * vx + vy * vy), 0, 1);
+          const vx = b[0] - a[0], vy = b[1] - a[1], wx = x - a[0], wy = y - a[1], t = clamp3((wx * vx + wy * vy) / (vx * vx + vy * vy), 0, 1);
           d = Math.min(d, Math.hypot(wx - vx * t, wy - vy * t));
         }
         return inside ? -d : d;
@@ -27583,7 +29900,7 @@ var GameUrban = (() => {
         c.roundBox(2.4, 0.1, 2.5, 0.04, blue, hx, hy0 + hh + 0.05, 0);
         const door = c.roundBox(0.05, 1.5, 0.66, 0.02, CM("#5a3e26"), hx - 1.3, hy0 + 0.8, 0.68, { rot: [0, 1.3, 0] });
         void door;
-        const inner = CM("#b9a888", { roughness: 0.9 });
+        const inner2 = CM("#b9a888", { roughness: 0.9 });
         c.roundBox(0.4, 0.95, 1.9, 0.03, wood, hx + 0.75, hy0 + 0.48, 0);
         c.roundBox(0.42, 0.03, 1.9, 0.01, CM("#2a2b2c"), hx + 0.75, hy0 + 0.97, 0);
         [-0.45, 0.45].forEach(function(z) {
@@ -27602,10 +29919,10 @@ var GameUrban = (() => {
           c.rod(new V3(0, 0, 0), new V3(0, Math.cos(a8) * 0.36, Math.sin(a8) * 0.36), 0.014, MT.wood, { parent: whl });
         }
         c.cylinder(0.05, 0.05, 0.14, MT.wood, 0.06, 0, 0, "x", { parent: whl });
-        kit.seat(c, hx - 0.05, hy0, 0, { w: 0.5, h: 0.55, back: 0.45, mat: inner, headrest: false });
+        kit.seat(c, hx - 0.05, hy0, 0, { w: 0.5, h: 0.55, back: 0.45, mat: inner2, headrest: false });
         c.roundBox(1.8, 0.12, 0.65, 0.04, CM("#7c5a3b"), hx - 0.2, hy0 + 0.5, -0.72);
         c.roundBox(1.7, 0.08, 0.55, 0.04, CM("#6b7c8f", { roughness: 1 }), hx - 0.2, hy0 + 0.6, -0.72);
-        c.roundBox(1.9, 0.02, 2.1, 0.01, inner, hx, hy0 + hh - 0.06, 0).castShadow = false;
+        c.roundBox(1.9, 0.02, 2.1, 0.01, inner2, hx, hy0 + hh - 0.06, 0).castShadow = false;
         c.cylinder(0.1, 0.1, 1.2, MT.trim, hx - 0.75, hy0 + hh + 0.6, 0.65);
         c.cylinder(0.13, 0.1, 0.1, MT.trim, hx - 0.75, hy0 + hh + 1.22, 0.65);
         c.rod(new V3(hx + 0.4, hy0 + hh + 0.1, 0), new V3(hx + 0.4, hy0 + hh + 1.6, 0), 0.04, wood);
@@ -31797,7 +34114,7 @@ var GameUrban = (() => {
     return (request, b) => {
       const context = contexts[request.kind];
       const key = `${seed}:${request.kind}:${request.x}:${request.z}`;
-      const id = options.pick ? options.pick(request, context, key) : pickForContext(region, context, key);
+      const id = options.pick ? options.pick(request, context, key) : (options.pickSpecies ?? ((table, spot) => pickForContext(region, table, spot)))(context, key);
       b.place("plant", id, request.x, request.z, { scale: request.scale, seed: key });
     };
   }