@adatechnology/game-floorplan 0.1.0 → 0.2.1

package/dist/index.global.js

@@ -21,10 +21,24 @@ var GameFloorplan = (() => {
   // src/index.ts
   var index_exports = {};
   __export(index_exports, {
+    blocksWindow: () => blocksWindow,
+    boxRadius: () => boxRadius,
     checkLot: () => checkLot,
+    createChalet: () => createChalet,
+    createCityBuilding: () => createCityBuilding,
+    createColonialHouse: () => createColonialHouse,
+    createCompanyHouse: () => createCompanyHouse,
+    createDetachedHouse: () => createDetachedHouse,
+    createFarmhouse: () => createFarmhouse,
     createRng: () => createRng,
+    createSilhouetteRandom: () => createSilhouetteRandom,
+    createSlabHouse: () => createSlabHouse,
+    createStiltHouse: () => createStiltHouse,
+    createTwoStoreyHouse: () => createTwoStoreyHouse,
     defineZone: () => defineZone,
     engine: () => engine,
+    findsAnswer: () => findsAnswer,
+    findsFor: () => findsFor,
     generate: () => generate,
     getZone: () => getZone,
     hashString: () => hashString,
@@ -38,6 +52,7 @@ var GameFloorplan = (() => {
     overlaps: () => overlaps,
     palette: () => palette,
     registerDecorProfile: () => registerDecorProfile,
+    registerFindsProvider: () => registerFindsProvider,
     registerGroundOverlay: () => registerGroundOverlay,
     registerItem: () => registerItem,
     registerItems: () => registerItems,
@@ -47,11 +62,13 @@ var GameFloorplan = (() => {
     registerPaletteStyle: () => registerPaletteStyle,
     registerPass: () => registerPass,
     registerPermeableGround: () => registerPermeableGround,
+    registerResultExtension: () => registerResultExtension,
     registerRoomColors: () => registerRoomColors,
     registerSeedKeys: () => registerSeedKeys,
     registerState: () => registerState,
     registerStyle: () => registerStyle,
     registerTemplate: () => registerTemplate,
+    registerViewerLayer: () => registerViewerLayer,
     registerWallTop: () => registerWallTop,
     setStateDistribution: () => setStateDistribution,
     slotKit: () => slotKit,
@@ -68,6 +85,227 @@ var GameFloorplan = (() => {
   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;
@@ -170,13 +408,39 @@ var GameFloorplan = (() => {
     };
   }
   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) {
@@ -231,7 +495,7 @@ var GameFloorplan = (() => {
           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";
@@ -254,6 +518,39 @@ var GameFloorplan = (() => {
     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 = [];
@@ -263,6 +560,7 @@ var GameFloorplan = (() => {
       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;
   }
@@ -284,7 +582,10 @@ var GameFloorplan = (() => {
     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(
@@ -309,8 +610,22 @@ var GameFloorplan = (() => {
   }
 
   // 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;
@@ -324,12 +639,18 @@ var GameFloorplan = (() => {
     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))
@@ -340,6 +661,22 @@ var GameFloorplan = (() => {
           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] };
   }
@@ -399,154 +736,12 @@ var GameFloorplan = (() => {
     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;
@@ -570,6 +765,7 @@ var GameFloorplan = (() => {
     }
     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];
@@ -587,9 +783,10 @@ var GameFloorplan = (() => {
     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) {
@@ -608,7 +805,7 @@ var GameFloorplan = (() => {
     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 = {
@@ -637,13 +834,18 @@ var GameFloorplan = (() => {
         _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];
@@ -666,19 +868,22 @@ var GameFloorplan = (() => {
         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;
@@ -689,14 +894,14 @@ var GameFloorplan = (() => {
             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);
@@ -719,9 +924,16 @@ var GameFloorplan = (() => {
           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;
           }
@@ -770,6 +982,8 @@ var GameFloorplan = (() => {
     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,
@@ -833,6 +1047,10 @@ var GameFloorplan = (() => {
       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) {
@@ -847,9 +1065,9 @@ var GameFloorplan = (() => {
             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) {
@@ -858,7 +1076,7 @@ var GameFloorplan = (() => {
         }
         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;
@@ -939,6 +1157,129 @@ var GameFloorplan = (() => {
     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();
@@ -1070,14 +1411,34 @@ var GameFloorplan = (() => {
     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 || [];
@@ -1093,7 +1454,8 @@ var GameFloorplan = (() => {
         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);
@@ -1101,7 +1463,7 @@ var GameFloorplan = (() => {
         }
         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";
@@ -1123,51 +1485,101 @@ var GameFloorplan = (() => {
           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);
@@ -1227,9 +1639,11 @@ var GameFloorplan = (() => {
       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 = [];
@@ -1287,12 +1701,14 @@ var GameFloorplan = (() => {
         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) };
@@ -1562,7 +1978,7 @@ var GameFloorplan = (() => {
       }
       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") {
@@ -1808,6 +2224,8 @@ var GameFloorplan = (() => {
     };
     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;
@@ -2077,6 +2495,214 @@ var GameFloorplan = (() => {
     }
   };
 
+  // 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");
@@ -2109,6 +2735,13 @@ var GameFloorplan = (() => {
     registerState,
     setStateDistribution,
     registerLocale,
+    registerResultExtension,
+    registerFindsProvider,
+    findsFor,
+    findsAnswer,
+    registerViewerLayer,
+    viewerLayers: VIEWER_LAYERS,
+    blocksWindow,
     // zoning
     defineZone,
     getZone,
@@ -2123,6 +2756,7 @@ var GameFloorplan = (() => {
     catalog: CATALOG,
     libraries: LIBRARIES,
     styles: STYLES,
+    paletteStyles: PALETTE_STYLES,
     createRng,
     mulberry32,
     hashString,
@@ -2130,7 +2764,7 @@ var GameFloorplan = (() => {
     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 }
   };
   return __toCommonJS(index_exports);
 })();