@adatechnology/game-floorplan 0.0.0-stage → 0.2.0

package/dist/index.js

@@ -0,0 +1,2745 @@
+// src/constants.ts
+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 };
+
+// src/registry.ts
+var CATALOG = {};
+var LIBRARIES = {};
+var LIBRARY_ALIAS = {};
+var TEMPLATES = {};
+var STYLES = {};
+var STYLE_ALIAS = {};
+var PALETTE_STYLES = {};
+var ROOM_COLORS = [];
+var PASSES = [];
+var DECOR_PROFILES = {};
+var GROUND_OVERLAYS = [];
+var STATE_PLUGINS = { normal: { apply: () => [] } };
+var WALL_TOP_HEIGHTS = { none: 0 };
+var SEED_KEYS = { rooms: {}, items: {} };
+var stateDistribution = { weights: null, seedKey: "state" };
+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;
+  return item;
+}
+function registerItems(list) {
+  for (const d of list) registerItem(d);
+}
+function registerLibrary(id, library) {
+  LIBRARIES[id] = library;
+}
+function registerLibraryAlias(alias, id) {
+  LIBRARY_ALIAS[alias] = id;
+}
+function registerTemplate(t) {
+  TEMPLATES[t.id] = t;
+  return t;
+}
+function registerStyle(style) {
+  STYLES[style.id] = style;
+  for (const a of style.aliases || []) STYLE_ALIAS[a] = style.id;
+}
+function registerPaletteStyle(id, def) {
+  PALETTE_STYLES[id] = def;
+}
+function registerRoomColors(list) {
+  for (const d of list) {
+    const i = ROOM_COLORS.findIndex((x) => x.type === d.type);
+    if (i >= 0) ROOM_COLORS.splice(i, 1);
+    ROOM_COLORS.push(d);
+  }
+  ROOM_COLORS.sort((a, b) => a.order - b.order);
+}
+function registerDecorProfile(styleId, profile) {
+  DECOR_PROFILES[styleId] = profile;
+}
+function registerPass(name, run) {
+  const i = PASSES.findIndex((p) => p.name === name);
+  if (i >= 0) PASSES[i] = { name, run };
+  else PASSES.push({ name, run });
+}
+function registerGroundOverlay(rule) {
+  GROUND_OVERLAYS.push(rule);
+}
+function registerWallTop(id, height) {
+  WALL_TOP_HEIGHTS[id] = height;
+}
+function registerSeedKeys(keys) {
+  Object.assign(SEED_KEYS.rooms, keys.rooms);
+  Object.assign(SEED_KEYS.items, keys.items);
+}
+function registerState(name, plugin) {
+  STATE_PLUGINS[name] = plugin;
+}
+function setStateDistribution(weights, seedKey = "state") {
+  stateDistribution.weights = weights;
+  stateDistribution.seedKey = seedKey;
+}
+var listStates = () => Object.keys(STATE_PLUGINS);
+function resolveStyleId(id) {
+  const s = id ?? "";
+  return STYLE_ALIAS[s] ?? s;
+}
+function styleOf(id) {
+  return STYLES[id] || STYLES.budget || Object.values(STYLES)[0];
+}
+var RESULT_EXTENSIONS = [];
+var FINDS_PROVIDERS = [];
+function registerResultExtension(name, run, options = {}) {
+  const entry = { name, run, after: options.after || [], seedKey: options.seedKey ?? name };
+  const i = RESULT_EXTENSIONS.findIndex((x) => x.name === name);
+  if (i >= 0) RESULT_EXTENSIONS[i] = entry;
+  else RESULT_EXTENSIONS.push(entry);
+}
+function registerFindsProvider(provider) {
+  FINDS_PROVIDERS.push(provider);
+}
+var VIEWER_LAYERS = [];
+function registerViewerLayer(layer) {
+  const i = VIEWER_LAYERS.findIndex((x) => x.id === layer.id);
+  if (i >= 0) VIEWER_LAYERS[i] = layer;
+  else VIEWER_LAYERS.push(layer);
+}
+
+// src/rng.ts
+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;
+}
+
+// src/extensions.ts
+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(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 FINDS_PROVIDERS) {
+    const stacks = provider.findsFor(query);
+    if (stacks !== null) return stacks;
+  }
+  return null;
+}
+
+// src/geometry.ts
+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;
+}
+
+// src/parking.ts
+var STEP = 0.05;
+var MAX_CANDIDATES = 80;
+function carCandidates(slot, item, car) {
+  const front = [slot.frontU, slot.frontV];
+  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 };
+  });
+}
+
+// src/queries.ts
+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);
+}
+
+// src/grid.ts
+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);
+  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;
+}
+
+// src/fill.ts
+function candidatesOf(cats) {
+  const out = [];
+  for (const [cat, weight] of Object.entries(cats)) {
+    const exact = cat[0] === "=";
+    const its = Object.values(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;
+  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: 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, parent.frontV];
+        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))) 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 process = (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];
+    process(u);
+    for (const m of u.members) done.add(m.id);
+  }
+  return { items, missing };
+}
+
+// src/legacy-seeds.ts
+var STREAM = {
+  facade: "fachada",
+  lot: "lote",
+  decor: "decor",
+  roomPrefix: "c:",
+  palettePrefix: "paleta:"
+};
+
+// src/context.ts
+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 ?? SEED_KEYS.rooms[room.id] ?? room.id,
+  shuffle,
+  facingRotation: (f, type) => rotationFor(f, CATALOG[type].front),
+  cutIntervals,
+  blocksWindow
+};
+function createPlacementContext(plan, items) {
+  const added = [];
+  const counters = {};
+  const make = (room, type, r, f, o) => {
+    const it = 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 = CATALOG[type];
+    if (it0.flat) opts.flat = true;
+    const it = 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 && overlaps(r, clearRect(m._r, [m.frontU, m.frontV], m.clearance)))) 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 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 PASSES) pass.run({ plan, items, seed, rng, ctx, kit: placementKit, catalog: CATALOG, profiles: DECOR_PROFILES });
+  groundCover(plan, items, ctx);
+  return ctx;
+}
+
+// src/locale.ts
+var locales = {};
+function registerLocale(code, table) {
+  const cur = locales[code] = locales[code] || {};
+  for (const ns of Object.keys(table)) cur[ns] = Object.assign(cur[ns] || {}, table[ns]);
+}
+var listLocales = () => Object.keys(locales);
+function translate(ns, key, locale = "en", vars) {
+  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;
+}
+
+// src/paths.ts
+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)) });
+  }
+}
+
+// src/zoning.ts
+var ZONES = {};
+var PERMEABLE_GROUNDS = /* @__PURE__ */ new Set();
+function defineZone(zone) {
+  if (!zone || !zone.id) throw new Error("defineZone: id is required");
+  ZONES[zone.id] = zone;
+  return zone;
+}
+var getZone = (id) => ZONES[id];
+var listZones = () => Object.values(ZONES);
+function registerPermeableGround(...types) {
+  for (const t of types) PERMEABLE_GROUNDS.add(t);
+}
+function resolveZone(z) {
+  if (!z) return null;
+  if (typeof z === "string") {
+    const found = 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 (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 = [...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) => 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) && !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);
+  }
+}
+
+// src/plan.ts
+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 byId = {};
+    for (const c of list) byId[c.id] = c;
+    const floorDoors = [];
+    (A.doors(w, d, op) || []).forEach((sp, i) => {
+      const a = byId[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 = byId[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, 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, 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 = byId[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 = byId[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 ZONES2 = [];
+  const libs = Object.assign({ garden: "garden", backyard: "backyard", parking: "parking", sideYard: "side_yard" }, cfg.libraries || {});
+  const addZone = (id, type, label, parts, library) => ZONES2.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"
+    };
+    g.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: ZONES2, 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 + 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 ZONES2) z.ground = (cfg.grounds || {})[z.id] || (cfg.grounds || {})[z.type] || pickWeighted(rLot, style.grounds[z.type] || { concrete: 1 });
+  if (bc.zone) enforcePermeability(lot, ZONES2, bc.zone, bc.adjustments || []);
+  plan.zones = ZONES2;
+  lot.zones = ZONES2;
+  plan.lot = lot;
+}
+
+// src/palette.ts
+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 (!PALETTE_STYLES[style]) style = PALETTE_STYLES.mid ? "mid" : Object.keys(PALETTE_STYLES)[0];
+  const def = 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 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));
+  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 = 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;
+}
+
+// src/slots.ts
+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 = LIBRARY_ALIAS[name] || name;
+  const library = room.slots ? room.slots : 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 byId = {};
+    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, byId, zones);
+      byId[def.id] = s;
+      all.push(s);
+    }
+  }
+  return all;
+}
+function resolveSlot(plan, room, def, byId, 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 = byId[def.parent];
+    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 = byId[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");
+      side = room.outdoor ? SIDE_OPPOSITE[win.side] : WINDOW_SIDE[win.side];
+      const cand = room.parts.map(inner).find(
+        (r) => (win.axis === "u" ? win.u >= r[0] - TOL && win.u <= r[2] + TOL : win.v >= r[1] - TOL && win.v <= r[3] + TOL) && (side === "left" && eq(r[0], win.pos + MARGIN) || side === "right" && eq(r[2], win.pos - MARGIN) || side === "front" && eq(r[1], win.pos + MARGIN) || side === "back" && eq(r[3], win.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");
+}
+
+// src/generate.ts
+function templateOf(t) {
+  if (typeof t === "string") {
+    if (!TEMPLATES[t]) throw new Error("Unknown template: " + t);
+    return 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 && STATE_PLUGINS[requested]) return requested;
+  const dist = stateDistribution.weights;
+  if (!dist) return "normal";
+  const x = createRng(seed, 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 || 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 = 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: CATALOG,
+    wallTopHeights: 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 ?? 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 colors = 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(colors.meta.base, locale, "facadeColors"), key: colors.meta.base, hex: hexString(colors.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 result = {
+    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,
+    building: tpl.building ? tpl.building(plan.w, plan.d, op) : null,
+    missing
+  };
+  if (tpl.singleFloor) result.floorNumber = op.floor || 3;
+  result.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(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 || {}
+    };
+  });
+}
+
+// src/ground-items.ts
+function registerGroundItems() {
+  const flat = { category: "ground_cover", w: 1, d: 1, h: 0, decor: true, mount: "ground", flat: true };
+  registerItems([
+    { type: "lawn", ...flat, color: { role: "lawn" } },
+    { type: "tile_floor", ...flat, color: { role: "exterior_floor" } },
+    { type: "concrete", ...flat, color: { role: "exterior_floor" } },
+    { type: "deck_floor", ...flat, color: { role: "deck_floor" } },
+    { type: "dirt", ...flat, color: { role: "dirt" } }
+  ]);
+}
+
+// src/slot-kit.ts
+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)
+};
+
+// src/locales/en.json
+var en_default = {
+  labels: {
+    floor_n: "Floor {n}",
+    parking: "Parking",
+    garden: "Garden",
+    backyard: "Backyard",
+    side_left: "Left side",
+    side_right: "Right side"
+  },
+  reasons: {
+    invalid_parent: "invalid parent",
+    invalid_side: "invalid side",
+    blocked_by_door: "blocked by a door",
+    open_wall: "open wall",
+    invalid_corner: "invalid corner",
+    no_window: "no window",
+    window_outside_room: "window outside the room",
+    larger_than_room: "slot larger than the room",
+    unknown_anchor: "unknown anchor"
+  },
+  messages: {
+    overlap: "Overlap: {a} and {b}",
+    door_blocked: "Door blocked by {id}",
+    gate_blocked: "Gate blocked by {id}",
+    missing_required: "Required item missing: {room}/{slot}",
+    zone_violation: "Zone {zone}: {rule} is {actual}, limit {limit}"
+  },
+  ui: {
+    title: "Floor plan viewer",
+    template: "Template",
+    seed: "Seed",
+    random_seed: "Random",
+    state: "State",
+    style: "Style",
+    zone: "Zone",
+    no_zone: "No zone (unrestricted)",
+    floor: "Floor",
+    outside: "Whole lot",
+    language: "Language",
+    width: "Width (m)",
+    depth: "Depth (m)",
+    auto_size: "Template default size",
+    options: "Options",
+    opt_floors: "Floors",
+    opt_elevator: "Elevator",
+    opt_tier: "Tier",
+    yes: "Yes",
+    no: "No",
+    default: "Default",
+    show_labels: "Labels",
+    show_items: "Items",
+    show_state: "State items",
+    show_lot: "Lot",
+    show_grid: "Grid",
+    legend: "Legend",
+    summary: "Summary",
+    rooms: "Rooms",
+    items: "Items",
+    state_items: "State items",
+    missing: "Missing required items",
+    none: "None",
+    validation: "Validation",
+    valid: "Valid plan",
+    zoning: "Zoning",
+    adjustments: "Adjustments",
+    violations: "Violations",
+    compliant: "Compliant with the zone",
+    hover: "Hover an item for details",
+    meters: "m",
+    use_label: "Use",
+    unit_floor: "Unit floor",
+    legend_wall: "Wall",
+    legend_door: "Door",
+    legend_window: "Window",
+    legend_gate: "Gate",
+    legend_path: "Path",
+    legend_item: "Furniture",
+    legend_state: "State item (outlined)",
+    rule_use: "Use not allowed",
+    rule_floors: "Too many floors",
+    rule_height: "Too tall",
+    rule_setback_front: "Front setback too small",
+    rule_setback_side: "Side setback too small",
+    rule_setback_back: "Back setback too small",
+    rule_min_lot: "Lot too small",
+    rule_min_frontage: "Frontage too narrow",
+    rule_coverage: "Coverage too high",
+    rule_far: "Floor area ratio too high",
+    rule_permeable: "Permeable area too small",
+    reason_max_floors: "Zone floor limit",
+    reason_max_height: "Zone height limit",
+    reason_setback_front: "Zone front setback",
+    reason_setback_side: "Zone side setback",
+    reason_setback_back: "Zone back setback",
+    reason_permeable_min: "Zone permeable area"
+  }
+};
+
+// src/locales/pt-BR.json
+var pt_BR_default = {
+  labels: {
+    floor_n: "Andar {n}",
+    parking: "Vaga",
+    garden: "Jardim",
+    backyard: "Quintal",
+    side_left: "Lateral esquerda",
+    side_right: "Lateral direita"
+  },
+  reasons: {
+    invalid_parent: "pai inv\xE1lido",
+    invalid_side: "lado inv\xE1lido",
+    blocked_by_door: "bloqueado por porta",
+    open_wall: "parede aberta",
+    invalid_corner: "canto inv\xE1lido",
+    no_window: "sem janela",
+    window_outside_room: "janela fora do c\xF4modo",
+    larger_than_room: "slot maior que o c\xF4modo",
+    unknown_anchor: "\xE2ncora desconhecida"
+  },
+  messages: {
+    overlap: "Sobreposi\xE7\xE3o: {a} e {b}",
+    door_blocked: "Porta bloqueada por {id}",
+    gate_blocked: "Port\xE3o bloqueado por {id}",
+    missing_required: "Item obrigat\xF3rio ausente: {room}/{slot}",
+    zone_violation: "Zona {zone}: {rule} \xE9 {actual}, limite {limit}"
+  },
+  ui: {
+    title: "Visualizador de plantas",
+    template: "Modelo",
+    seed: "Semente",
+    random_seed: "Aleat\xF3ria",
+    state: "Estado",
+    style: "Estilo",
+    zone: "Zona",
+    no_zone: "Sem zona (livre)",
+    floor: "Andar",
+    outside: "Lote inteiro",
+    language: "Idioma",
+    width: "Largura (m)",
+    depth: "Profundidade (m)",
+    auto_size: "Tamanho padr\xE3o do modelo",
+    options: "Op\xE7\xF5es",
+    opt_floors: "Andares",
+    opt_elevator: "Elevador",
+    opt_tier: "Padr\xE3o",
+    yes: "Sim",
+    no: "N\xE3o",
+    default: "Padr\xE3o",
+    show_labels: "R\xF3tulos",
+    show_items: "M\xF3veis",
+    show_state: "Itens de estado",
+    show_lot: "Lote",
+    show_grid: "Grade",
+    legend: "Legenda",
+    summary: "Resumo",
+    rooms: "C\xF4modos",
+    items: "M\xF3veis",
+    state_items: "Itens de estado",
+    missing: "Itens obrigat\xF3rios ausentes",
+    none: "Nenhum",
+    validation: "Valida\xE7\xE3o",
+    valid: "Planta v\xE1lida",
+    zoning: "Zoneamento",
+    adjustments: "Ajustes",
+    violations: "Viola\xE7\xF5es",
+    compliant: "Em conformidade com a zona",
+    hover: "Passe o mouse sobre um item para ver detalhes",
+    meters: "m",
+    use_label: "Uso",
+    unit_floor: "Andar da unidade",
+    legend_wall: "Parede",
+    legend_door: "Porta",
+    legend_window: "Janela",
+    legend_gate: "Port\xE3o",
+    legend_path: "Caminho",
+    legend_item: "M\xF3vel",
+    legend_state: "Item de estado (contorno)",
+    rule_use: "Uso n\xE3o permitido",
+    rule_floors: "Andares demais",
+    rule_height: "Altura excedida",
+    rule_setback_front: "Recuo frontal insuficiente",
+    rule_setback_side: "Recuo lateral insuficiente",
+    rule_setback_back: "Recuo de fundos insuficiente",
+    rule_min_lot: "Lote pequeno demais",
+    rule_min_frontage: "Testada estreita demais",
+    rule_coverage: "Taxa de ocupa\xE7\xE3o excedida",
+    rule_far: "Coeficiente de aproveitamento excedido",
+    rule_permeable: "\xC1rea perme\xE1vel insuficiente",
+    reason_max_floors: "Limite de andares da zona",
+    reason_max_height: "Limite de altura da zona",
+    reason_setback_front: "Recuo frontal da zona",
+    reason_setback_side: "Recuo lateral da zona",
+    reason_setback_back: "Recuo de fundos da zona",
+    reason_permeable_min: "\xC1rea perme\xE1vel da zona"
+  }
+};
+
+// src/silhouettes/random.ts
+function createSilhouetteRandom(seed) {
+  let state = seed;
+  return () => {
+    state |= 0;
+    state = state + 1831565813 | 0;
+    let t = Math.imul(state ^ state >>> 15, 1 | state);
+    t = t + Math.imul(t ^ t >>> 7, 61 | t) ^ t;
+    return ((t ^ t >>> 14) >>> 0) / 4294967296;
+  };
+}
+
+// src/silhouettes/builder.ts
+var ROOT = -1;
+var MAX_BOX_RADIUS = 0.15;
+var BOX_RADIUS_RATIO = 0.22;
+var PLAIN_BOX_RADIUS = 0.012;
+function boxRadius(width, height, depth) {
+  const radius = Math.min(Math.min(width, height, depth) * BOX_RADIUS_RATIO, MAX_BOX_RADIUS);
+  return radius < PLAIN_BOX_RADIUS ? 0 : radius;
+}
+function createSilhouetteBuilder(random) {
+  const parts = [];
+  const windows = [];
+  const pick = (list) => list[Math.floor(random() * list.length)];
+  const group = (x, y, z, ry = 0, parent = ROOT) => parts.push({ shape: "group", parent, x, y, z, ry }) - 1;
+  const box = (x, y, z, width, height, depth, color, o = {}) => {
+    parts.push({ shape: "box", parent: o.parent ?? ROOT, x, y: y + height / 2, z, width, height, depth, color, emissive: o.emissive ?? false, ry: o.ry ?? 0, rz: o.rz ?? 0, radius: boxRadius(width, height, depth) });
+  };
+  const prism = (x, y, z, width, height, depth, color, parent = ROOT) => {
+    parts.push({ shape: "prism", parent, x, y, z, width, height, depth, color, ry: 0 });
+  };
+  const cylinder = (x, y, z, radiusTop, radiusBottom, height, color, parent = ROOT, segments = 14) => {
+    parts.push({ shape: "cylinder", parent, x, y: y + height / 2, z, radiusTop, radiusBottom, height, color, segments });
+  };
+  const line = (points, color, parent = ROOT) => {
+    parts.push({ shape: "line", parent, points, color });
+  };
+  const sign = (text, x, y, z, width, height, ry, colors, parent = ROOT) => {
+    parts.push({ shape: "sign", parent, x, y, z, width, height, ry, text, ...colors });
+  };
+  const fence = (x0, z0, x1, z1, height, color, parent = ROOT) => {
+    const length = Math.hypot(x1 - x0, z1 - z0);
+    const count = Math.ceil(length / 3);
+    for (let index = 0; index <= count; index++) {
+      const t = index / count;
+      cylinder(x0 + (x1 - x0) * t, 0, z0 + (z1 - z0) * t, 0.05, 0.05, height, color, parent, 5);
+    }
+    for (const level of [height * 0.35, height * 0.65, height * 0.98]) line([[x0, level, z0], [x1, level, z1]], 9079950, parent);
+  };
+  const finish = (footprint) => ({ parts, windows, footprint });
+  return { random, pick, group, box, prism, cylinder, line, sign, fence, windows, finish };
+}
+
+// src/silhouettes/building.ts
+var STOREY_HEIGHT = 3;
+var SHOP_AWNING_HEIGHT = 4.5;
+var WINDOW_COLUMN_WIDTH = 2.6;
+var SHOP_SIGNS = ["FARM\xC1CIA", "MAGAZINE", "LOT\xC9RICA", "PADARIA", "\xD3TICA", "CAL\xC7ADOS", "BAR"];
+var SIGN_COLORS = ["#ffd27a", "#e8dfcf", "#c4483b"];
+var DEFAULT_LIT_CHANCE = 0.07;
+function createCityBuilding(p) {
+  const random = p.random ?? createSilhouetteRandom(p.seed ?? 7);
+  const b = createSilhouetteBuilder(random);
+  const { x, z, width: w, depth: d, height: h } = p;
+  b.box(x, 0, z, w, h, d, p.color);
+  b.box(x, h, z, w + 0.3, 0.35, d + 0.3, 2763308);
+  if (random() < 0.4) b.cylinder(x + (random() - 0.5) * (w - 3), h + 0.35, z + (random() - 0.5) * (d - 3), 0.8, 0.8, 1.4, 4932928);
+  const hasShop = p.shopChance !== void 0 && p.shopChance > 0 && random() < p.shopChance;
+  if (hasShop) {
+    for (const face of [1, -1]) {
+      const zFace = z + face * (d / 2);
+      b.box(x, SHOP_AWNING_HEIGHT, zFace + face * 0.8, w, 0.2, 1.6, 2763308);
+      b.box(x, 0, zFace + face * 0.03, w * 0.6, 3.5, 0.05, 4869198);
+      const text = b.pick(SHOP_SIGNS);
+      b.sign(text, x, 5.3, zFace + face * 0.12, Math.min(w * 0.7, 8), 1, face > 0 ? 0 : Math.PI, { background: "#1a1a1c", foreground: b.pick(SIGN_COLORS) });
+    }
+  }
+  addWindows(b, p, hasShop ? SHOP_AWNING_HEIGHT : 0);
+  return b.finish({ x, z, width: w, depth: d, height: h + 0.35 });
+}
+function addWindows(b, p, base) {
+  const { x, z, width: w, depth: d, height: h } = p;
+  const floors = Math.max(1, Math.floor((h - 1) / STOREY_HEIGHT));
+  const faces = [[0, d / 2 + 0.03, w, 0], [0, -d / 2 - 0.03, w, Math.PI], [w / 2 + 0.03, 0, d, Math.PI / 2], [-w / 2 - 0.03, 0, d, -Math.PI / 2]];
+  for (const [ox, oz, faceWidth, ry] of faces) {
+    const columns = Math.max(1, Math.floor(faceWidth / WINDOW_COLUMN_WIDTH));
+    for (let floor = 0; floor < floors; floor++) {
+      const y = base + 1.8 + floor * STOREY_HEIGHT;
+      for (let column = 0; column < columns; column++) {
+        const u = (column - (columns - 1) / 2) * WINDOW_COLUMN_WIDTH;
+        b.windows.push({ x: ox ? x + ox : x + u, y, z: ox ? z + u : z + oz, ry, width: 1.2, height: 1.4, isLit: b.random() < (p.litChance || DEFAULT_LIT_CHANCE) });
+      }
+    }
+  }
+}
+
+// src/silhouettes/houses.ts
+var LIT_WINDOW = 16757854;
+var DARK_WINDOW = 1053979;
+var DEFAULT_ROOF = 5913130;
+var randomOf = (o) => o.random ?? createSilhouetteRandom(o.seed ?? 7);
+var pane = (isLit) => ({ color: isLit ? LIT_WINDOW : DARK_WINDOW, emissive: isLit });
+function createTwoStoreyHouse(p) {
+  const b = createSilhouetteBuilder(randomOf(p));
+  const { width: w, depth: d } = p;
+  const g = b.group(p.x, 0, p.z, p.ry);
+  b.box(0, 0, 0, w, 6, d, p.color, { parent: g });
+  b.prism(0, 6, 0, w + 0.4, 1.4, d + 0.4, p.roofColor ?? DEFAULT_ROOF, g);
+  b.box(0, 3.1, d / 2 + 0.5, w * 0.6, 0.15, 1, 6974054, { parent: g });
+  for (const floor of [0, 1]) {
+    for (const side of [-1, 1]) {
+      const { color, emissive } = pane(b.random() < 0.12);
+      b.box(side * w * 0.26, 1.1 + floor * 3, d / 2 + 0.03, 1.1, 1.2, 0.04, color, { parent: g, emissive });
+    }
+  }
+  b.box(0, 0, d / 2 + 0.02, 1, 2.1, 0.05, 2759956, { parent: g });
+  return b.finish({ x: p.x, z: p.z, width: w, depth: d, height: 7.4 });
+}
+function createSlabHouse(p) {
+  const b = createSilhouetteBuilder(randomOf(p));
+  const { width: w, depth: d, floors } = p;
+  const g = b.group(p.x, 0, p.z, 0);
+  for (let floor = 0; floor < floors; floor++) {
+    const isTop = floor === floors - 1;
+    b.box(0, floor * 2.9, 0, w, 2.9, d, isTop && b.random() < 0.5 ? 10119760 : p.color, { parent: g });
+    const { color, emissive } = pane(b.random() < 0.1);
+    b.box(0, floor * 2.9 + 1.1, d / 2 + 0.03, 1, 1, 0.04, color, { parent: g, emissive });
+  }
+  b.cylinder(w * 0.25, floors * 2.9, -d * 0.2, 0.55, 0.55, 0.9, 2775712, g, 10);
+  for (let level = 0; level < floors; level++) b.box(w / 2 + 0.4, level * 2.9, 0, 0.8, 0.18, 1.2, 8026740, { parent: g });
+  if (b.random() < 0.6) for (let index = 0; index < 4; index++) b.box(-w * 0.3 + index * 0.4, floors * 2.9, 0, 0.02, 1, 0.02, 9079434, { parent: g });
+  return b.finish({ x: p.x, z: p.z, width: w, depth: d, height: floors * 2.9 + 1 });
+}
+function createColonialHouse(p) {
+  const b = createSilhouetteBuilder(randomOf(p));
+  const { width: w } = p;
+  const g = b.group(p.x, 0, p.z, 0);
+  b.box(0, 0, 0, w, 4.2, 10, p.color, { parent: g });
+  b.box(0, 4.2, 4.6, w, 0.8, 0.25, p.color, { parent: g });
+  b.prism(0, 4.2, -0.4, w, 1.4, 9.6, 8014386, g);
+  const count = Math.max(1, Math.floor(w / 2.2));
+  for (let index = 0; index < count; index++) {
+    const u = (index - (count - 1) / 2) * 2.2;
+    const isDoor = index === 0 && p.hasDoor;
+    const lit = isDoor ? false : b.random() < 0.15;
+    const color = isDoor ? 3810326 : lit ? LIT_WINDOW : 2767434;
+    b.box(u, 1, 5.02, 0.9, 2, 0.05, color, { parent: g, emissive: lit });
+  }
+  return b.finish({ x: p.x, z: p.z, width: w, depth: 10, height: 6 });
+}
+function createChalet(p) {
+  const b = createSilhouetteBuilder(randomOf(p));
+  const g = b.group(p.x, 0, p.z, p.ry);
+  b.box(0, 0, 0, 7, 0.8, 9, 5920336, { parent: g });
+  b.box(0, 0.8, 0, 7, 4.2, 9, p.color ?? 7031344, { parent: g });
+  b.prism(0, 5, 0, 7.6, 4, 9.6, 2894376, g);
+  b.box(2.2, 5, -1, 0.8, 4.2, 0.8, 5920336, { parent: g });
+  const { color, emissive } = pane(b.random() < 0.3);
+  b.box(0, 1.6, 4.52, 1.3, 1.3, 0.04, color, { parent: g, emissive });
+  b.box(0, 6.2, 4.6, 1, 1, 0.04, DARK_WINDOW, { parent: g });
+  return b.finish({ x: p.x, z: p.z, width: 7.6, depth: 9.6, height: 9 });
+}
+function createCompanyHouse(p) {
+  const b = createSilhouetteBuilder(randomOf(p));
+  const g = b.group(p.x, 0, p.z, 0);
+  b.box(0, 0, 0, 6, 3, 9, p.color ?? 14209216, { parent: g });
+  b.prism(0, 3, 0, 6.4, 1.6, 9.4, 9062962, g);
+  b.box(0, 0, 4.52, 0.9, 2.1, 0.05, 3811868, { parent: g });
+  b.box(1.8, 1.1, 4.52, 1, 1, 0.04, DARK_WINDOW, { parent: g });
+  b.fence(-3.2, 6.5, 3.2, 6.5, 0.9, 14735560, g);
+  return b.finish({ x: p.x, z: p.z, width: 6.4, depth: 13, height: 4.6 });
+}
+function createStiltHouse(p) {
+  const b = createSilhouetteBuilder(randomOf(p));
+  const g = b.group(p.x, 0, p.z, 0);
+  for (const a of [-2, 2]) for (const c of [-3, 3]) b.cylinder(a, -1.5, c, 0.12, 0.12, 3.1, 3811868, g, 6);
+  b.box(0, 1.5, 0, 5, 0.2, 7, 5916208, { parent: g });
+  b.box(0, 1.7, 0, 4.6, 2.6, 6.4, p.color ?? 6969926, { parent: g });
+  b.prism(0, 4.3, 0, 5.2, 1.1, 7, 8026744, g);
+  b.box(0, 1.5, 5, 1.2, 0.15, 4, 5916208, { parent: g });
+  return b.finish({ x: p.x, z: p.z, width: 5.2, depth: 9, height: 5.4 });
+}
+function createFarmhouse(p) {
+  const b = createSilhouetteBuilder(randomOf(p));
+  const g = b.group(p.x, 0, p.z, 0);
+  b.box(0, 0, 0, 15, 3.2, 11, 14208952, { parent: g });
+  b.prism(0, 3.2, 0, 17, 2.2, 13, 9062962, g);
+  b.box(0, 0, 6.8, 15, 0.25, 2.6, 6969926, { parent: g });
+  for (let index = 0; index < 6; index++) b.cylinder(-7 + index * 2.8, 0, 7.8, 0.1, 0.1, 3.2, 5916208, g, 6);
+  b.box(-3, 1, 5.52, 1.2, 1.2, 0.04, LIT_WINDOW, { parent: g, emissive: true });
+  return b.finish({ x: p.x, z: p.z, width: 17, depth: 13, height: 5.4 });
+}
+function createDetachedHouse(p) {
+  const b = createSilhouetteBuilder(randomOf(p));
+  const { width: w, depth: d } = p;
+  const g = b.group(p.x, 0, p.z, p.ry);
+  b.box(0, 0, 0, w, 3, d, p.color, { parent: g });
+  b.prism(0, 3, 0, w + 0.5, 1.6, d + 0.5, p.roofColor ?? DEFAULT_ROOF, g);
+  b.box(0, 0, d / 2 + 0.02, 1, 2.1, 0.05, 2759956, { parent: g });
+  for (const side of [-1, 1]) {
+    const { color, emissive } = pane(b.random() < 0.15);
+    b.box(side * w * 0.28, 1.1, d / 2 + 0.03, 1.1, 1.1, 0.04, color, { parent: g, emissive });
+    if (p.isBoarded || b.random() < 0.3) for (const k of [-1, 1]) b.box(side * w * 0.28, 1.5 + k * 0.25, d / 2 + 0.08, 1.3, 0.14, 0.04, 7031338, { parent: g, rz: k * 0.15 });
+  }
+  return b.finish({ x: p.x, z: p.z, width: w + 0.5, depth: d + 0.5, height: 4.6 });
+}
+
+// src/index.ts
+registerGroundItems();
+registerPermeableGround("lawn", "dirt");
+registerLocale("en", en_default);
+registerLocale("pt-BR", pt_BR_default);
+var version = "0.1.0";
+var engine = {
+  version,
+  generate,
+  slots,
+  validate,
+  palette,
+  limitsOf,
+  listTemplates,
+  listStates,
+  // content registration
+  registerItem,
+  registerItems,
+  registerLibrary,
+  registerLibraryAlias,
+  registerTemplate,
+  registerStyle,
+  registerPaletteStyle,
+  registerRoomColors,
+  registerDecorProfile,
+  registerPass,
+  registerGroundOverlay,
+  registerWallTop,
+  registerSeedKeys,
+  registerState,
+  setStateDistribution,
+  registerLocale,
+  registerResultExtension,
+  registerFindsProvider,
+  findsFor,
+  findsAnswer,
+  registerViewerLayer,
+  viewerLayers: VIEWER_LAYERS,
+  blocksWindow,
+  // zoning
+  defineZone,
+  getZone,
+  listZones,
+  checkLot,
+  registerPermeableGround,
+  // kits and data
+  slotKit,
+  translate,
+  listLocales,
+  templates: TEMPLATES,
+  catalog: CATALOG,
+  libraries: LIBRARIES,
+  styles: STYLES,
+  paletteStyles: 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 }
+};
+export {
+  blocksWindow,
+  checkLot,
+  createChalet,
+  createCityBuilding,
+  createColonialHouse,
+  createCompanyHouse,
+  createDetachedHouse,
+  createFarmhouse,
+  createRng,
+  createSilhouetteRandom,
+  createSlabHouse,
+  createStiltHouse,
+  createTwoStoreyHouse,
+  defineZone,
+  engine,
+  findsAnswer,
+  findsFor,
+  generate,
+  getZone,
+  hashString,
+  limitsOf,
+  listLocales,
+  listStates,
+  listTemplates,
+  listZones,
+  mulberry32,
+  openingZones,
+  overlaps,
+  palette,
+  registerDecorProfile,
+  registerFindsProvider,
+  registerGroundOverlay,
+  registerItem,
+  registerItems,
+  registerLibrary,
+  registerLibraryAlias,
+  registerLocale,
+  registerPaletteStyle,
+  registerPass,
+  registerPermeableGround,
+  registerResultExtension,
+  registerRoomColors,
+  registerSeedKeys,
+  registerState,
+  registerStyle,
+  registerTemplate,
+  registerViewerLayer,
+  registerWallTop,
+  setStateDistribution,
+  slotKit,
+  slots,
+  translate,
+  validate,
+  version,
+  windowZone
+};
+//# sourceMappingURL=index.js.map