@adatechnology/game-floorplan 0.1.0 → 0.2.0

package/dist/index.js

@@ -4,6 +4,227 @@ 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;
@@ -106,13 +327,39 @@ function normalizeRoom(c, floorIndex) {
   };
 }
 function usableParts(room, extra) {
-  return room.parts.map((p) => {
-    const isOpen = (k) => room.parts.some(
-      (q) => q !== p && (k === 0 ? eq(q[2], p[0]) && Math.min(q[3], p[3]) - Math.max(q[1], p[1]) > 0.3 : k === 2 ? eq(q[0], p[2]) && Math.min(q[3], p[3]) - Math.max(q[1], p[1]) > 0.3 : k === 1 ? eq(q[3], p[1]) && Math.min(q[2], p[2]) - Math.max(q[0], p[0]) > 0.3 : eq(q[1], p[3]) && Math.min(q[2], p[2]) - Math.max(q[0], p[0]) > 0.3)
-    );
-    const m = MARGIN + (extra || 0);
-    return [p[0] + (isOpen(0) ? 0 : m), p[1] + (isOpen(1) ? 0 : m), p[2] - (isOpen(2) ? 0 : m), p[3] - (isOpen(3) ? 0 : m)];
-  });
+  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) {
@@ -167,7 +414,7 @@ function buildWalls(rooms, doors, openPairs, floorIndex) {
         pieces = n;
       }
       for (const [x, y] of pieces) {
-        const isOpen = (t) => t === "balcony" || t === "terrace";
+        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";
@@ -190,6 +437,39 @@ function buildWalls(rooms, doors, openPairs, floorIndex) {
   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 = [];
@@ -199,6 +479,7 @@ function zonesOfFloor(plan, floorIndex) {
     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;
 }
@@ -220,7 +501,10 @@ function windowZone(j, outside) {
   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];
 }
-var blocksWindow = (it, win) => !it.window || it.h > 1 + EPS || it.h > win.y0 - 0.05;
+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(
@@ -245,8 +529,22 @@ function isOpenSide(plan, room, pu, pv) {
 }
 
 // src/grid.ts
-function createGrid(plan, room, ignored) {
-  const gs = room.outdoor ? 0.3 : 0.2;
+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;
@@ -260,12 +558,18 @@ function createGrid(plan, room, ignored) {
   const nx = Math.ceil((u1 - u0) / gs);
   const nz = Math.ceil((v1 - v0) / gs);
   const insideCells = new Uint8Array(nx * nz);
-  const insets = usableParts(room, 0.08);
+  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])) insideCells[j * nx + i] = 1;
+      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))
@@ -276,6 +580,22 @@ function createGrid(plan, room, ignored) {
         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] };
 }
@@ -335,154 +655,12 @@ function reachable(g, solids, inflation) {
   return true;
 }
 
-// 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];
-}
-
-// 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/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.category === cat || i.type === cat));
+    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;
@@ -506,6 +684,7 @@ function itemRect(slot, it, shift) {
   }
   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];
@@ -523,9 +702,10 @@ function fillRoom(plan, room, slots2, rng) {
   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 : 0.12;
+  const inflation = room.outdoor ? 0.15 : plan.playerRadius;
   const units = [];
   const seen = {};
   for (const s of slots2) {
@@ -544,7 +724,7 @@ function fillRoom(plan, room, slots2, rng) {
   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) => {
+  const make = (s, it, r, parent, overheadOff) => {
     const f = [s.frontU, s.frontV];
     const id = room.id + "." + s.id;
     const m = {
@@ -573,13 +753,18 @@ function fillRoom(plan, room, slots2, rng) {
       _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) => {
+  const tryFit = (s, relax, overheadOff) => {
     const cands = weightedOrder(candidatesOf(s.cats), rng);
     if (s.anchor === "on" || s.anchor === "inside") {
       const parent = state[s.on];
@@ -602,19 +787,22 @@ function fillRoom(plan, room, slots2, rng) {
       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;
-      for (const shift of shifts) {
-        const r3 = itemRect(s, it, shift);
+      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) && 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 = null;
-        if (!relax && s.clearance > 0 && !it.low) {
+        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;
@@ -625,14 +813,14 @@ function fillRoom(plan, room, slots2, rng) {
           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 (!reachable(grid, solids.concat([r3]), inflation)) 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);
+      const m = make(s, it, r, null, overheadOff);
       if (cl) reserves.push(cl);
       if (rimRect) rims.push(rimRect);
       solids.push(r);
@@ -655,9 +843,16 @@ function fillRoom(plan, room, slots2, rng) {
         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)) {
+        if (tryFit(m, true, true)) {
           ok = true;
           break;
         }
@@ -706,6 +901,8 @@ var placementKit = {
   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,
@@ -769,6 +966,10 @@ function createPlacementContext(plan, items) {
     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) {
@@ -783,9 +984,9 @@ function createPlacementContext(plan, items) {
           cand.push([x, z, x + extentU, z + extentV]);
         }
       }
-    for (const r of shuffle(cand, rng2)) {
+    for (const r of opts.ordered ? cand : shuffle(cand, rng2)) {
       if (!insideUnion(r, inners)) continue;
-      if (zones.some((z) => overlaps(r, z))) 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) {
@@ -794,7 +995,7 @@ function createPlacementContext(plan, items) {
       }
       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]), 0.16)) continue;
+      if (!reachable(opts.railing || gridOf(room), solidList.concat([r]), room.outdoor ? 0.16 : plan.playerRadius)) continue;
       return r;
     }
     return null;
@@ -875,6 +1076,129 @@ function translate(ns, key, locale = "en", vars) {
   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();
@@ -1006,14 +1330,34 @@ function buildPlan(tpl, wIn, dIn, opIn, bc = {}) {
   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: {} };
+  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 : floorIndex * A.ceiling,
+      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 || [];
@@ -1029,7 +1373,8 @@ function buildPlan(tpl, wIn, dIn, opIn, bc = {}) {
       const a = byId[sp.a];
       if (!a) throw new Error("Door references a missing room: " + sp.a);
       let edge;
-      if (sp.b === "outside") edge = exteriorEdge(a, sp.side, w, d, sp.at);
+      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);
@@ -1037,7 +1382,7 @@ function buildPlan(tpl, wIn, dIn, opIn, bc = {}) {
       }
       if (!edge) throw new Error("Door without a wall: " + sp.a + " / " + sp.b);
       const width = sp.width;
-      const margin = width / 2 + 0.12;
+      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";
@@ -1059,51 +1404,101 @@ function buildPlan(tpl, wIn, dIn, opIn, bc = {}) {
         exterior,
         side: sp.side || null,
         leaves: exterior && sp.steel ? 0 : width > 1.1 ? 2 : 1,
-        model: sp.steel ? "steel" : width > 1.1 ? "double" : "single",
+        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 windowsOut = [];
-    (A.windows(w, d, op) || []).forEach((windowDef) => {
-      const a = byId[windowDef.room];
-      if (!a) throw new Error("Window references a missing room: " + windowDef.room);
-      const edge = exteriorEdge(a, windowDef.side, w, d, windowDef.at);
-      if (!edge) return;
-      const width = windowDef.width;
-      const m0 = edge.a0 + width / 2 + 0.3;
-      const m1 = edge.a1 - width / 2 - 0.3;
-      if (m1 < m0 - TOL) return;
-      const centers = windowDef.n ? Array.from({ length: windowDef.n }, (_, i) => edge.a0 + (edge.a1 - edge.a0) * (i + 1) / (windowDef.n + 1)) : [windowDef.at];
-      for (const c0 of centers) {
-        const c = clamp(c0, m0, m1);
-        const u = edge.axis === "u" ? c : edge.pos;
-        const v = edge.axis === "u" ? edge.pos : c;
-        if (floorDoors.some((p) => p.axis === edge.axis && eq(p.pos, edge.pos) && Math.abs(p.at - c) < (p.width + width) / 2 + 0.15)) continue;
-        if (windowsOut.some((j) => j.axis === edge.axis && eq(j.pos, edge.pos) && Math.abs(j.at - c) < (j.width + width) / 2 + 0.2)) continue;
-        windowsOut.push({
-          id: "w" + floorIndex + "_" + windowsOut.length,
-          floor: floorIndex,
-          u: r2(u),
-          v: r2(v),
-          axis: edge.axis,
-          pos: edge.pos,
-          at: r2(c),
-          width,
-          y0: windowDef.y0 || 1,
-          y1: windowDef.y1 || 2.15,
-          room: windowDef.room,
-          side: windowDef.side
-        });
-      }
-    });
+    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(...buildWalls(list, floorDoors, A.openPairs || [], floorIndex).map((p) => Object.assign(p, { h: p.h || A.ceiling })));
+    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);
@@ -1163,9 +1558,11 @@ function buildLot(plan, tpl, w, d, op, style, styleId, bc) {
     parts.sort((a, b) => b[2] - b[0] - (a[2] - a[0]));
     addZone("garden", "garden", "garden", parts, libs.garden);
   }
-  if (backDepth > 0 && cfg.yardZones) {
-    for (const q of cfg.yardZones) addZone(q.id, q.type, q.label || q.id, [[-marginL, d + q.v0, w + marginR, d + Math.min(backDepth, q.v1)]], q.library);
+  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 = [];
@@ -1223,12 +1620,14 @@ function buildLot(plan, tpl, w, d, op, style, styleId, bc) {
       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" ? 2 : style.height;
+    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) };
@@ -1498,7 +1897,7 @@ function resolveSlot(plan, room, def, byId, zones) {
     }
     return roomCenter;
   };
-  const free = (rect) => !zones.some((z) => overlaps(rect, z, room.type === "stairs" ? -0.011 : EPS));
+  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") {
@@ -1744,6 +2143,8 @@ function generate(template, options) {
   };
   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;
@@ -2013,6 +2414,214 @@ var pt_BR_default = {
   }
 };
 
+// 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");
@@ -2045,6 +2654,13 @@ var engine = {
   registerState,
   setStateDistribution,
   registerLocale,
+  registerResultExtension,
+  registerFindsProvider,
+  findsFor,
+  findsAnswer,
+  registerViewerLayer,
+  viewerLayers: VIEWER_LAYERS,
+  blocksWindow,
   // zoning
   defineZone,
   getZone,
@@ -2059,6 +2675,7 @@ var engine = {
   catalog: CATALOG,
   libraries: LIBRARIES,
   styles: STYLES,
+  paletteStyles: PALETTE_STYLES,
   createRng,
   mulberry32,
   hashString,
@@ -2066,13 +2683,26 @@ var engine = {
   windowZone,
   openingZones,
   color: { lstar, hex: hexString, hsl: intToHsl, HIGH_SATURATION, MIN_WALL_FLOOR_CONTRAST, MIN_FABRIC_FLOOR_CONTRAST },
-  constants: { WALL_THICKNESS, DOOR_CLEARANCE }
+  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,
@@ -2086,6 +2716,7 @@ export {
   overlaps,
   palette,
   registerDecorProfile,
+  registerFindsProvider,
   registerGroundOverlay,
   registerItem,
   registerItems,
@@ -2095,11 +2726,13 @@ export {
   registerPaletteStyle,
   registerPass,
   registerPermeableGround,
+  registerResultExtension,
   registerRoomColors,
   registerSeedKeys,
   registerState,
   registerStyle,
   registerTemplate,
+  registerViewerLayer,
   registerWallTop,
   setStateDistribution,
   slotKit,