@adatechnology/game-floorplan 0.2.1 → 0.3.0

package/dist/index.js

@@ -1,134 +1,120 @@
-// src/constants.ts
-var WALL_THICKNESS = 0.15;
-var MARGIN = WALL_THICKNESS / 2;
-var EPS = 1e-6;
-var TOL = 1e-3;
-var DOOR_CLEARANCE = 0.9;
-var PLAYER_RADIUS = 0.24;
-var DOOR_EDGE_CLEARANCE = 0.12;
-var WINDOW_EDGE_CLEARANCE = 0.3;
-var OVERHEAD_TOP = 2.15;
-var WINDOWLESS_ROOM_TYPES = /* @__PURE__ */ new Set([
-  "stockroom",
-  "kitchen",
-  "laundry",
-  "bathroom",
-  "void",
-  "elevator",
-  "stairs",
-  "pantry",
-  "closet",
-  "corridor",
-  "hall",
-  "balcony",
-  "terrace",
-  "garage",
-  "storage",
-  "porch",
-  "tent",
-  "outhouse"
-]);
-var CAR_CLEARANCE = { driver: 0.8, side: 0.6, end: 0.6 };
-
 // src/registry.ts
-var CATALOG = {};
-var LIBRARIES = {};
-var LIBRARY_ALIAS = {};
-var TEMPLATES = {};
-var STYLES = {};
-var STYLE_ALIAS = {};
-var PALETTE_STYLES = {};
-var ROOM_COLORS = [];
-var PASSES = [];
-var DECOR_PROFILES = {};
-var GROUND_OVERLAYS = [];
-var STATE_PLUGINS = { normal: { apply: () => [] } };
-var WALL_TOP_HEIGHTS = { none: 0 };
-var SEED_KEYS = { rooms: {}, items: {} };
-var stateDistribution = { weights: null, seedKey: "state" };
+var createRegistries = () => ({
+  CATALOG: {},
+  LIBRARIES: {},
+  LIBRARY_ALIAS: {},
+  TEMPLATES: {},
+  STYLES: {},
+  STYLE_ALIAS: {},
+  PALETTE_STYLES: {},
+  ROOM_COLORS: [],
+  PASSES: [],
+  DECOR_PROFILES: {},
+  GROUND_OVERLAYS: [],
+  STATE_PLUGINS: { normal: { apply: () => [] } },
+  WALL_TOP_HEIGHTS: { none: 0 },
+  SEED_KEYS: { rooms: {}, items: {} },
+  stateDistribution: { weights: null, seedKey: "state" },
+  RESULT_EXTENSIONS: [],
+  FINDS_PROVIDERS: [],
+  VIEWER_LAYERS: [],
+  LOCALES: {},
+  ZONES: {},
+  PERMEABLE_GROUNDS: /* @__PURE__ */ new Set()
+});
+var defaultRegistries;
+var activeRegistries;
+var getDefaultRegistries = () => defaultRegistries ?? (defaultRegistries = createRegistries());
+var registries = () => activeRegistries ?? getDefaultRegistries();
+function withRegistries(scope, run) {
+  const previous = activeRegistries;
+  activeRegistries = scope;
+  try {
+    return run();
+  } finally {
+    activeRegistries = previous;
+  }
+}
 function registerItem(def) {
   const h = def.h;
   const item = Object.assign({ front: "+z", window: h <= 0.95, low: h <= 0.5, flat: false, deck: false, rim: 0 }, def);
-  CATALOG[def.type] = item;
+  registries().CATALOG[def.type] = item;
   return item;
 }
 function registerItems(list) {
   for (const d of list) registerItem(d);
 }
 function registerLibrary(id, library) {
-  LIBRARIES[id] = library;
+  registries().LIBRARIES[id] = library;
 }
 function registerLibraryAlias(alias, id) {
-  LIBRARY_ALIAS[alias] = id;
+  registries().LIBRARY_ALIAS[alias] = id;
 }
 function registerTemplate(t) {
-  TEMPLATES[t.id] = t;
+  registries().TEMPLATES[t.id] = t;
   return t;
 }
 function registerStyle(style) {
-  STYLES[style.id] = style;
-  for (const a of style.aliases || []) STYLE_ALIAS[a] = style.id;
+  registries().STYLES[style.id] = style;
+  for (const a of style.aliases || []) registries().STYLE_ALIAS[a] = style.id;
 }
 function registerPaletteStyle(id, def) {
-  PALETTE_STYLES[id] = def;
+  registries().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);
+    const i = registries().ROOM_COLORS.findIndex((x) => x.type === d.type);
+    if (i >= 0) registries().ROOM_COLORS.splice(i, 1);
+    registries().ROOM_COLORS.push(d);
   }
-  ROOM_COLORS.sort((a, b) => a.order - b.order);
+  registries().ROOM_COLORS.sort((a, b) => a.order - b.order);
 }
 function registerDecorProfile(styleId, profile) {
-  DECOR_PROFILES[styleId] = profile;
+  registries().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 });
+  const i = registries().PASSES.findIndex((p) => p.name === name);
+  if (i >= 0) registries().PASSES[i] = { name, run };
+  else registries().PASSES.push({ name, run });
 }
 function registerGroundOverlay(rule) {
-  GROUND_OVERLAYS.push(rule);
+  registries().GROUND_OVERLAYS.push(rule);
 }
 function registerWallTop(id, height) {
-  WALL_TOP_HEIGHTS[id] = height;
+  registries().WALL_TOP_HEIGHTS[id] = height;
 }
 function registerSeedKeys(keys) {
-  Object.assign(SEED_KEYS.rooms, keys.rooms);
-  Object.assign(SEED_KEYS.items, keys.items);
+  Object.assign(registries().SEED_KEYS.rooms, keys.rooms);
+  Object.assign(registries().SEED_KEYS.items, keys.items);
 }
 function registerState(name, plugin) {
-  STATE_PLUGINS[name] = plugin;
+  registries().STATE_PLUGINS[name] = plugin;
 }
 function setStateDistribution(weights, seedKey = "state") {
-  stateDistribution.weights = weights;
-  stateDistribution.seedKey = seedKey;
+  registries().stateDistribution.weights = weights;
+  registries().stateDistribution.seedKey = seedKey;
 }
-var listStates = () => Object.keys(STATE_PLUGINS);
+var listStates = () => Object.keys(registries().STATE_PLUGINS);
 function resolveStyleId(id) {
   const s = id ?? "";
-  return STYLE_ALIAS[s] ?? s;
+  return registries().STYLE_ALIAS[s] ?? s;
 }
 function styleOf(id) {
-  return STYLES[id] || STYLES.budget || Object.values(STYLES)[0];
+  return registries().STYLES[id] || registries().STYLES.budget || Object.values(registries().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);
+  const i = registries().RESULT_EXTENSIONS.findIndex((x) => x.name === name);
+  if (i >= 0) registries().RESULT_EXTENSIONS[i] = entry;
+  else registries().RESULT_EXTENSIONS.push(entry);
 }
 function registerFindsProvider(provider) {
-  FINDS_PROVIDERS.push(provider);
+  registries().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);
+  const i = registries().VIEWER_LAYERS.findIndex((x) => x.id === layer.id);
+  if (i >= 0) registries().VIEWER_LAYERS[i] = layer;
+  else registries().VIEWER_LAYERS.push(layer);
 }
 
 // src/rng.ts
@@ -208,7 +194,7 @@ function orderOf(extensions) {
   return ordered;
 }
 function runResultExtensions(plan, result, seed, options) {
-  for (const extension of orderOf(RESULT_EXTENSIONS)) {
+  for (const extension of orderOf(registries().RESULT_EXTENSIONS)) {
     result[extension.name] = extension.run({ plan, result, seed, rng: createRng(seed, extension.seedKey), options });
   }
 }
@@ -219,13 +205,45 @@ function findsAnswer(query) {
   return answerOf(query);
 }
 function answerOf(query) {
-  for (const provider of FINDS_PROVIDERS) {
+  for (const provider of registries().FINDS_PROVIDERS) {
     const stacks = provider.findsFor(query);
     if (stacks !== null) return stacks;
   }
   return null;
 }
 
+// src/constants.ts
+var WALL_THICKNESS = 0.15;
+var MARGIN = WALL_THICKNESS / 2;
+var EPS = 1e-6;
+var TOL = 1e-3;
+var DOOR_CLEARANCE = 0.9;
+var PLAYER_RADIUS = 0.24;
+var DOOR_EDGE_CLEARANCE = 0.12;
+var WINDOW_EDGE_CLEARANCE = 0.3;
+var OVERHEAD_TOP = 2.15;
+var WINDOWLESS_ROOM_TYPES = /* @__PURE__ */ new Set([
+  "stockroom",
+  "kitchen",
+  "laundry",
+  "bathroom",
+  "void",
+  "elevator",
+  "stairs",
+  "pantry",
+  "closet",
+  "corridor",
+  "hall",
+  "balcony",
+  "terrace",
+  "garage",
+  "storage",
+  "porch",
+  "tent",
+  "outhouse"
+]);
+var CAR_CLEARANCE = { driver: 0.8, side: 0.6, end: 0.6 };
+
 // src/geometry.ts
 var r2 = (x) => Math.round(x * 100) / 100;
 var clamp = (x, a, b) => Math.max(a, Math.min(b, x));
@@ -559,7 +577,7 @@ function createGrid(plan, room, ignored, radius = plan.playerRadius) {
   const nz = Math.ceil((v1 - v0) / gs);
   const insideCells = new Uint8Array(nx * nz);
   const insets = room.outdoor ? usableParts(room, 0.08) : room.parts;
-  const bodies = room.outdoor ? null : wallBodies(plan, room.floor);
+  const bodies = room.outdoor ? null : wallBodies(plan, room.floor).filter((r) => r[0] - radius <= u1 && r[2] + radius >= u0 && r[1] - radius <= v1 && r[3] + radius >= v0);
   const tooClose = (u, v) => bodies.some((r) => {
     const dx = Math.max(r[0] - u, 0, u - r[2]);
     const dz = Math.max(r[1] - v, 0, v - r[3]);
@@ -660,7 +678,7 @@ function candidatesOf(cats) {
   const out = [];
   for (const [cat, weight] of Object.entries(cats)) {
     const exact = cat[0] === "=";
-    const its = Object.values(CATALOG).filter((i) => !i.decor && (exact ? i.type === cat.slice(1) : !i.exactOnly && (i.category === cat || i.type === cat)));
+    const its = Object.values(registries().CATALOG).filter((i) => !i.decor && (exact ? i.type === cat.slice(1) : !i.exactOnly && (i.category === cat || i.type === cat)));
     for (const it of its) out.push({ it, weight: weight / its.length });
   }
   return out;
@@ -751,7 +769,7 @@ function fillRoom(plan, room, slots2, rng) {
       low: it.low,
       aabb: r.map(r2),
       _r: r,
-      _seedId: SEED_KEYS.items[id] ?? id
+      _seedId: registries().SEED_KEYS.items[id] ?? id
     };
     if (it.overhead) m.overhead = !overheadOff;
     if (it.category === "car") {
@@ -902,9 +920,9 @@ var placementKit = {
   clearRect,
   pickWeighted,
   createRng,
-  roomSeedKey: (room) => room.seedKey ?? SEED_KEYS.rooms[room.id] ?? room.id,
+  roomSeedKey: (room) => room.seedKey ?? registries().SEED_KEYS.rooms[room.id] ?? room.id,
   shuffle,
-  facingRotation: (f, type) => rotationFor(f, CATALOG[type].front),
+  facingRotation: (f, type) => rotationFor(f, registries().CATALOG[type].front),
   cutIntervals,
   blocksWindow
 };
@@ -912,7 +930,7 @@ function createPlacementContext(plan, items) {
   const added = [];
   const counters = {};
   const make = (room, type, r, f, o) => {
-    const it = CATALOG[type];
+    const it = registries().CATALOG[type];
     const n = counters[room.id + type] = (counters[room.id + type] || 0) + 1;
     return Object.assign(
       {
@@ -958,9 +976,9 @@ function createPlacementContext(plan, items) {
   const gridOf = (c) => gridCache[c.id] || (gridCache[c.id] = createGrid(plan, c, ignored));
   function placeOnFloor(room, type, rng2, optsIn) {
     const opts = Object.assign({}, optsIn || {});
-    const it0 = CATALOG[type];
+    const it0 = registries().CATALOG[type];
     if (it0.flat) opts.flat = true;
-    const it = CATALOG[type];
+    const it = registries().CATALOG[type];
     const inners = usableParts(room, 0);
     const solidList = solidsOfRoom(room);
     const zones = zonesOfFloor(plan, room.floor);
@@ -1039,7 +1057,7 @@ function groundCover(plan, items, ctx) {
     z.parts.forEach((p, i) => groundPiece(z, z.ground, p, 0, i));
     let k = 0;
     const clip = (r) => z.parts.map((p) => [Math.max(r[0], p[0]), Math.max(r[1], p[1]), Math.min(r[2], p[2]), Math.min(r[3], p[3])]).filter((q) => q[2] - q[0] > 0.3 && q[3] - q[1] > 0.3).sort((a, b) => areaOf(b) - areaOf(a))[0];
-    for (const rule of GROUND_OVERLAYS) {
+    for (const rule of registries().GROUND_OVERLAYS) {
       const triggers = items.filter((m) => m.room === z.id && m.category === rule.category);
       if (rule.merge) {
         if (triggers.length && z.ground !== rule.unlessGround) {
@@ -1059,19 +1077,20 @@ function groundCover(plan, items, ctx) {
 function runPostProcess(plan, items, seed) {
   const ctx = createPlacementContext(plan, items);
   const rng = createRng(seed, STREAM.decor);
-  for (const pass of PASSES) pass.run({ plan, items, seed, rng, ctx, kit: placementKit, catalog: CATALOG, profiles: DECOR_PROFILES });
+  for (const pass of registries().PASSES) pass.run({ plan, items, seed, rng, ctx, kit: placementKit, catalog: registries().CATALOG, profiles: registries().DECOR_PROFILES });
   groundCover(plan, items, ctx);
   return ctx;
 }
 
 // src/locale.ts
-var locales = {};
 function registerLocale(code, table) {
+  const { LOCALES: locales } = registries();
   const cur = locales[code] = locales[code] || {};
   for (const ns of Object.keys(table)) cur[ns] = Object.assign(cur[ns] || {}, table[ns]);
 }
-var listLocales = () => Object.keys(locales);
+var listLocales = () => Object.keys(registries().LOCALES);
 function translate(ns, key, locale = "en", vars) {
+  const { LOCALES: locales } = registries();
   const raw = locales[locale]?.[ns]?.[key] ?? locales.en?.[ns]?.[key] ?? key;
   return vars ? raw.replace(/\{(\w+)\}/g, (m, k) => k in vars ? String(vars[k]) : m) : raw;
 }
@@ -1200,22 +1219,20 @@ function addExteriorDoorPaths(plan, c) {
 }
 
 // src/zoning.ts
-var ZONES = {};
-var PERMEABLE_GROUNDS = /* @__PURE__ */ new Set();
 function defineZone(zone) {
   if (!zone || !zone.id) throw new Error("defineZone: id is required");
-  ZONES[zone.id] = zone;
+  registries().ZONES[zone.id] = zone;
   return zone;
 }
-var getZone = (id) => ZONES[id];
-var listZones = () => Object.values(ZONES);
+var getZone = (id) => registries().ZONES[id];
+var listZones = () => Object.values(registries().ZONES);
 function registerPermeableGround(...types) {
-  for (const t of types) PERMEABLE_GROUNDS.add(t);
+  for (const t of types) registries().PERMEABLE_GROUNDS.add(t);
 }
 function resolveZone(z) {
   if (!z) return null;
   if (typeof z === "string") {
-    const found = ZONES[z];
+    const found = registries().ZONES[z];
     if (!found) throw new Error("Unknown zone: " + z);
     return found;
   }
@@ -1261,7 +1278,7 @@ function checkLot(zoneIn, lot, plan) {
   const far = m.built / area;
   if (far > zone.maxFar + 1e-9) out.push({ rule: "far", actual: r2(far), limit: zone.maxFar });
   let permeable = 0;
-  for (const z of lot.zones) if (PERMEABLE_GROUNDS.has(z.ground)) for (const p of z.parts) permeable += (p[2] - p[0]) * (p[3] - p[1]);
+  for (const z of lot.zones) if (registries().PERMEABLE_GROUNDS.has(z.ground)) for (const p of z.parts) permeable += (p[2] - p[0]) * (p[3] - p[1]);
   const permeability = permeable / area;
   if (permeability < zone.permeableMin - 1e-9) out.push({ rule: "permeable", actual: r2(permeability), limit: zone.permeableMin });
   return out;
@@ -1299,14 +1316,14 @@ function clampLotToZone(cfg, zone, adjustments, partyWalls = []) {
 }
 var ADJUSTABLE_ZONES = /* @__PURE__ */ new Set(["garden", "backyard", "side_yard"]);
 function enforcePermeability(lot, zones, zone, adjustments) {
-  const target = [...PERMEABLE_GROUNDS][0];
+  const target = [...registries().PERMEABLE_GROUNDS][0];
   if (!target) return;
   const [u0, v0, u1, v1] = lot.rect;
   const area = (u1 - u0) * (v1 - v0);
   const areaOfZone = (z) => z.parts.reduce((s, p) => s + (p[2] - p[0]) * (p[3] - p[1]), 0);
-  let permeable = zones.filter((z) => PERMEABLE_GROUNDS.has(z.ground)).reduce((s, z) => s + areaOfZone(z), 0);
+  let permeable = zones.filter((z) => registries().PERMEABLE_GROUNDS.has(z.ground)).reduce((s, z) => s + areaOfZone(z), 0);
   if (permeable / area >= zone.permeableMin) return;
-  const candidates = zones.filter((z) => ADJUSTABLE_ZONES.has(z.type) && !PERMEABLE_GROUNDS.has(z.ground)).sort((a, b) => areaOfZone(b) - areaOfZone(a));
+  const candidates = zones.filter((z) => ADJUSTABLE_ZONES.has(z.type) && !registries().PERMEABLE_GROUNDS.has(z.ground)).sort((a, b) => areaOfZone(b) - areaOfZone(a));
   for (const z of candidates) {
     if (permeable / area >= zone.permeableMin) break;
     adjustments.push({ field: "ground:" + z.id, from: z.ground, to: target, reason: "permeable_min" });
@@ -1539,9 +1556,9 @@ function buildLot(plan, tpl, w, d, op, style, styleId, bc) {
     paths: [],
     pool: !!cfg.pool
   };
-  const ZONES2 = [];
+  const ZONES = [];
   const libs = Object.assign({ garden: "garden", backyard: "backyard", parking: "parking", sideYard: "side_yard" }, cfg.libraries || {});
-  const addZone = (id, type, label, parts, library) => ZONES2.push(Object.assign(normalizeRoom({ id, type, label, rect: parts[0], parts: parts.slice(1), library, outdoor: true }, -1), { floor: -1, outdoor: true }));
+  const addZone = (id, type, label, parts, library) => ZONES.push(Object.assign(normalizeRoom({ id, type, label, rect: parts[0], parts: parts.slice(1), library, outdoor: true }, -1), { floor: -1, outdoor: true }));
   if (setback > 0) {
     let parts = [[-marginL, -setback, w + marginR, 0]];
     if (cfg.parking) {
@@ -1621,14 +1638,14 @@ function buildLot(plan, tpl, w, d, op, style, styleId, bc) {
     }
   }
   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 });
+  else addExteriorDoorPaths(plan, { gates, paths, zones: ZONES, setback, marginLeft: marginL, marginRight: marginR, backyard: backDepth, w, target: cfg.doorTarget });
   plan.paths = paths;
   lot.paths = paths;
   const boundary = (rule) => {
     const type = pickWeighted(rLot, rule.type);
     const top = type === "railing" ? "none" : pickWeighted(rLot, rule.top);
     const wallHeight = type === "railing" ? 1.2 : type === "fence" ? style.fenceHeight ?? 2 : style.height;
-    return { type, material: type === "wall" ? "block" : type === "fence" ? "wire_mesh" : "iron", height: wallHeight, top, totalHeight: r2(wallHeight + WALL_TOP_HEIGHTS[top]), thickness: WALL_THICKNESS };
+    return { type, material: type === "wall" ? "block" : type === "fence" ? "wire_mesh" : "iron", height: wallHeight, top, totalHeight: r2(wallHeight + registries().WALL_TOP_HEIGHTS[top]), thickness: WALL_THICKNESS };
   };
   const A = { front: boundary(style.front), left: boundary(style.sideYard), right: boundary(style.sideYard), back: boundary(style.back) };
   const seg = (side, u0, v0, u1, v1) => {
@@ -1661,10 +1678,10 @@ function buildLot(plan, tpl, w, d, op, style, styleId, bc) {
   else if (backDepth > 0) seg("left", 0, d, 0, d + backDepth);
   if (marginR > 0.5) seg("right", w + marginR, vi, w + marginR, d + backDepth);
   else if (backDepth > 0) seg("right", w, d, w, d + backDepth);
-  for (const z of ZONES2) z.ground = (cfg.grounds || {})[z.id] || (cfg.grounds || {})[z.type] || pickWeighted(rLot, style.grounds[z.type] || { concrete: 1 });
-  if (bc.zone) enforcePermeability(lot, ZONES2, bc.zone, bc.adjustments || []);
-  plan.zones = ZONES2;
-  lot.zones = ZONES2;
+  for (const z of ZONES) z.ground = (cfg.grounds || {})[z.id] || (cfg.grounds || {})[z.type] || pickWeighted(rLot, style.grounds[z.type] || { concrete: 1 });
+  if (bc.zone) enforcePermeability(lot, ZONES, bc.zone, bc.adjustments || []);
+  plan.zones = ZONES;
+  lot.zones = ZONES;
   plan.lot = lot;
 }
 
@@ -1714,8 +1731,8 @@ var hexString = (n) => "#" + (n >>> 0).toString(16).padStart(6, "0");
 function palette(o) {
   const opt = o || {};
   let style = resolveStyleId(opt.style || "budget");
-  if (!PALETTE_STYLES[style]) style = PALETTE_STYLES.mid ? "mid" : Object.keys(PALETTE_STYLES)[0];
-  const def = PALETTE_STYLES[style];
+  if (!registries().PALETTE_STYLES[style]) style = registries().PALETTE_STYLES.mid ? "mid" : Object.keys(registries().PALETTE_STYLES)[0];
+  const def = registries().PALETTE_STYLES[style];
   const state = opt.state || "normal";
   const seed = opt.seed == null ? 1 : opt.seed;
   const rng = createRng(seed, STREAM.palettePrefix + (def.seedKey ?? style));
@@ -1733,14 +1750,14 @@ function palette(o) {
   const { wallMode, sMax } = early;
   const R = Object.assign({}, early.roles);
   const ctx = Object.assign({ style, sMax, wallMode, generalFloor: early.generalFloor }, draw);
-  for (const c of ROOM_COLORS) {
+  for (const c of registries().ROOM_COLORS) {
     const [wh, wl] = c.wall(ctx);
     R["wall_" + c.type] = hsl(wh, c.neutral ? Math.min(0.16, sMax) : clamp(jit(sMax * 0.75, sMax * 0.5), 0.03, sMax), jit(wl, 0.03));
     const pi = c.floor || early.generalFloor;
     R["floor_" + c.type] = hsl(pi[0], Math.min(pi[1], wallMode ? 0.18 : 0.3), jit(pi[2], 0.04));
   }
   Object.assign(R, def.late(draw, early));
-  STATE_PLUGINS[state]?.adjustPalette?.(R);
+  registries().STATE_PLUGINS[state]?.adjustPalette?.(R);
   const adjust = (color, ref, min, preferredDir) => {
     for (let i = 0; i < 60; i++) {
       if (Math.abs(lstar(hslToInt(color.h, color.s, color.l)) - lstar(hslToInt(ref.h, ref.s, ref.l))) >= min) return;
@@ -1750,7 +1767,7 @@ function palette(o) {
       color.l = clamp(color.l + dir * 0.015, 0.04, 0.96);
     }
   };
-  const types = ROOM_COLORS.map((c) => c.type);
+  const types = registries().ROOM_COLORS.map((c) => c.type);
   for (const c of types) {
     const w = R["wall_" + c];
     const p = R["floor_" + c];
@@ -1804,8 +1821,8 @@ var SIDE_OPPOSITE = { front: "back", back: "front", left: "right", right: "left"
 var WINDOW_SIDE = { front: "front", back: "back", left: "left", right: "right" };
 function slotDefsOf(plan, room) {
   const name = room.library || room.type;
-  const key = LIBRARY_ALIAS[name] || name;
-  const library = room.slots ? room.slots : LIBRARIES[key];
+  const key = registries().LIBRARY_ALIAS[name] || name;
+  const library = room.slots ? room.slots : registries().LIBRARIES[key];
   if (!library) return [];
   const R = inner(room.parts[0]);
   let defs = typeof library === "function" ? library({ w: R[2] - R[0], d: R[3] - R[1] }) : library.slice();
@@ -1995,8 +2012,8 @@ function resolveSlot(plan, room, def, byId, zones) {
 // src/generate.ts
 function templateOf(t) {
   if (typeof t === "string") {
-    if (!TEMPLATES[t]) throw new Error("Unknown template: " + t);
-    return TEMPLATES[t];
+    if (!registries().TEMPLATES[t]) throw new Error("Unknown template: " + t);
+    return registries().TEMPLATES[t];
   }
   return t;
 }
@@ -2014,10 +2031,10 @@ function slots(template, options) {
   return resolveSlots(plan).map(cleanSlot).map((s) => s.reason ? Object.assign(s, { reason: translate("reasons", s.reason, locale) }) : s);
 }
 function pickState(requested, seed) {
-  if (requested && STATE_PLUGINS[requested]) return requested;
-  const dist = stateDistribution.weights;
+  if (requested && registries().STATE_PLUGINS[requested]) return requested;
+  const dist = registries().stateDistribution.weights;
   if (!dist) return "normal";
-  const x = createRng(seed, stateDistribution.seedKey)();
+  const x = createRng(seed, registries().stateDistribution.seedKey)();
   let acc = 0;
   const keys = Object.keys(dist);
   for (const k of keys) {
@@ -2027,13 +2044,13 @@ function pickState(requested, seed) {
   return keys[keys.length - 1];
 }
 function colorOf(m, seed) {
-  const spec = m.colorSpec || CATALOG[m.type]?.color || { role: "wood" };
+  const spec = m.colorSpec || registries().CATALOG[m.type]?.color || { role: "wood" };
   if ("role" in spec) return spec.role;
   if ("hex" in spec) return spec.hex;
   return spec.pick[hashString(seed + "|" + (m._seedId ?? m.id)) % spec.pick.length];
 }
 function applyState(plan, items, ctx, seed, state) {
-  const plugin = STATE_PLUGINS[state];
+  const plugin = registries().STATE_PLUGINS[state];
   if (!plugin || state === "normal") return [];
   const c = {
     plan,
@@ -2043,8 +2060,8 @@ function applyState(plan, items, ctx, seed, state) {
     rng: createRng(seed, plugin.seedKey ?? "state:" + state),
     ctx,
     kit: placementKit,
-    catalog: CATALOG,
-    wallTopHeights: WALL_TOP_HEIGHTS
+    catalog: registries().CATALOG,
+    wallTopHeights: registries().WALL_TOP_HEIGHTS
   };
   return plugin.apply(c);
 }
@@ -2064,7 +2081,7 @@ function generate(template, options) {
   const missing = [];
   for (const room of plan.rooms.concat(plan.zones)) {
     const sl = all.filter((s) => s.room === room.id && s.floor === room.floor);
-    const r = fillRoom(plan, room, sl, createRng(seed, STREAM.roomPrefix + (room.seedKey ?? SEED_KEYS.rooms[room.id] ?? room.id)));
+    const r = fillRoom(plan, room, sl, createRng(seed, STREAM.roomPrefix + (room.seedKey ?? registries().SEED_KEYS.rooms[room.id] ?? room.id)));
     items.push(...r.items);
     missing.push(...r.missing);
   }
@@ -2177,7 +2194,7 @@ function limitsOf(template, options) {
   return { limits: tpl.limitsFn ? tpl.limitsFn(op) : tpl.limits, defaults: tpl.defaultsFn ? tpl.defaultsFn(op) : tpl.defaults };
 }
 function listTemplates(locale = "en") {
-  return Object.values(TEMPLATES).map((t) => {
+  return Object.values(registries().TEMPLATES).map((t) => {
     const a = floorsOf(t, {});
     return {
       id: t.id,
@@ -2194,6 +2211,9 @@ function listTemplates(locale = "en") {
   });
 }
 
+// src/instance.ts
+import { applyPatches, removeIds } from "@adatechnology/game-contracts";
+
 // src/ground-items.ts
 function registerGroundItems() {
   const flat = { category: "ground_cover", w: 1, d: 1, h: 0, decor: true, mount: "ground", flat: true };
@@ -2414,6 +2434,109 @@ var pt_BR_default = {
   }
 };
 
+// src/instance.ts
+var version = "0.1.0";
+function editCatalog(catalog, patch, remove) {
+  if (!patch && !remove) return;
+  const entries = new Map(Object.entries(catalog).map(([key, definition]) => [key, { ...definition, id: key }]));
+  applyPatches(entries, patch);
+  removeIds(entries, remove);
+  for (const key of Object.keys(catalog)) {
+    const edited = entries.get(key);
+    if (!edited) delete catalog[key];
+    else if (patch && key in patch) {
+      const hadId = "id" in catalog[key];
+      const next = { ...edited };
+      if (!hadId) delete next.id;
+      catalog[key] = next;
+    }
+  }
+}
+function buildEngine(scope) {
+  const scoped = (fn) => ((...args) => withRegistries(scope, () => fn(...args)));
+  return {
+    version,
+    generate: scoped(generate),
+    slots: scoped(slots),
+    validate: scoped(validate),
+    palette: scoped(palette),
+    limitsOf: scoped(limitsOf),
+    listTemplates: scoped(listTemplates),
+    listStates: scoped(listStates),
+    // content registration
+    registerItem: scoped(registerItem),
+    registerItems: scoped(registerItems),
+    registerLibrary: scoped(registerLibrary),
+    registerLibraryAlias: scoped(registerLibraryAlias),
+    registerTemplate: scoped(registerTemplate),
+    registerStyle: scoped(registerStyle),
+    registerPaletteStyle: scoped(registerPaletteStyle),
+    registerRoomColors: scoped(registerRoomColors),
+    registerDecorProfile: scoped(registerDecorProfile),
+    registerPass: scoped(registerPass),
+    registerGroundOverlay: scoped(registerGroundOverlay),
+    registerWallTop: scoped(registerWallTop),
+    registerSeedKeys: scoped(registerSeedKeys),
+    registerState: scoped(registerState),
+    setStateDistribution: scoped(setStateDistribution),
+    registerLocale: scoped(registerLocale),
+    registerResultExtension: scoped(registerResultExtension),
+    registerFindsProvider: scoped(registerFindsProvider),
+    findsFor: scoped(findsFor),
+    findsAnswer: scoped(findsAnswer),
+    registerViewerLayer: scoped(registerViewerLayer),
+    viewerLayers: scope.VIEWER_LAYERS,
+    blocksWindow: scoped(blocksWindow),
+    // zoning
+    defineZone: scoped(defineZone),
+    getZone: scoped(getZone),
+    listZones: scoped(listZones),
+    checkLot: scoped(checkLot),
+    registerPermeableGround: scoped(registerPermeableGround),
+    // kits and data
+    slotKit,
+    translate: scoped(translate),
+    listLocales: scoped(listLocales),
+    templates: scope.TEMPLATES,
+    catalog: scope.CATALOG,
+    libraries: scope.LIBRARIES,
+    styles: scope.STYLES,
+    paletteStyles: scope.PALETTE_STYLES,
+    createRng,
+    mulberry32,
+    hashString,
+    overlaps,
+    windowZone,
+    openingZones,
+    color: { lstar, hex: hexString, hsl: intToHsl, HIGH_SATURATION, MIN_WALL_FLOOR_CONTRAST, MIN_FABRIC_FLOOR_CONTRAST },
+    constants: { WALL_THICKNESS, DOOR_CLEARANCE, PLAYER_RADIUS, DOOR_EDGE_CLEARANCE, WINDOW_EDGE_CLEARANCE, OVERHEAD_TOP, CAR_CLEARANCE }
+  };
+}
+function seedBase(scope) {
+  withRegistries(scope, () => {
+    registerGroundItems();
+    registerPermeableGround("lawn", "dirt");
+    registerLocale("en", en_default);
+    registerLocale("pt-BR", pt_BR_default);
+  });
+}
+function createFloorplan(options = {}) {
+  const scope = createRegistries();
+  seedBase(scope);
+  const instance = buildEngine(scope);
+  for (const pack of options.packs ?? []) (typeof pack === "function" ? pack : pack.register)(instance);
+  editCatalog(scope.CATALOG, options.patch?.items, options.remove?.items);
+  editCatalog(scope.TEMPLATES, options.patch?.templates, options.remove?.templates);
+  return instance;
+}
+var defaultEngine;
+function defaultFloorplan() {
+  if (defaultEngine) return defaultEngine;
+  seedBase(getDefaultRegistries());
+  defaultEngine = buildEngine(getDefaultRegistries());
+  return defaultEngine;
+}
+
 // src/silhouettes/random.ts
 function createSilhouetteRandom(seed) {
   let state = seed;
@@ -2623,68 +2746,7 @@ function createDetachedHouse(p) {
 }
 
 // src/index.ts
-registerGroundItems();
-registerPermeableGround("lawn", "dirt");
-registerLocale("en", en_default);
-registerLocale("pt-BR", pt_BR_default);
-var version = "0.1.0";
-var engine = {
-  version,
-  generate,
-  slots,
-  validate,
-  palette,
-  limitsOf,
-  listTemplates,
-  listStates,
-  // content registration
-  registerItem,
-  registerItems,
-  registerLibrary,
-  registerLibraryAlias,
-  registerTemplate,
-  registerStyle,
-  registerPaletteStyle,
-  registerRoomColors,
-  registerDecorProfile,
-  registerPass,
-  registerGroundOverlay,
-  registerWallTop,
-  registerSeedKeys,
-  registerState,
-  setStateDistribution,
-  registerLocale,
-  registerResultExtension,
-  registerFindsProvider,
-  findsFor,
-  findsAnswer,
-  registerViewerLayer,
-  viewerLayers: VIEWER_LAYERS,
-  blocksWindow,
-  // zoning
-  defineZone,
-  getZone,
-  listZones,
-  checkLot,
-  registerPermeableGround,
-  // kits and data
-  slotKit,
-  translate,
-  listLocales,
-  templates: TEMPLATES,
-  catalog: CATALOG,
-  libraries: LIBRARIES,
-  styles: STYLES,
-  paletteStyles: PALETTE_STYLES,
-  createRng,
-  mulberry32,
-  hashString,
-  overlaps,
-  windowZone,
-  openingZones,
-  color: { lstar, hex: hexString, hsl: intToHsl, HIGH_SATURATION, MIN_WALL_FLOOR_CONTRAST, MIN_FABRIC_FLOOR_CONTRAST },
-  constants: { WALL_THICKNESS, DOOR_CLEARANCE, PLAYER_RADIUS, DOOR_EDGE_CLEARANCE, WINDOW_EDGE_CLEARANCE, OVERHEAD_TOP, CAR_CLEARANCE }
-};
+var engine = defaultFloorplan();
 export {
   blocksWindow,
   boxRadius,
@@ -2695,11 +2757,13 @@ export {
   createCompanyHouse,
   createDetachedHouse,
   createFarmhouse,
+  createFloorplan,
   createRng,
   createSilhouetteRandom,
   createSlabHouse,
   createStiltHouse,
   createTwoStoreyHouse,
+  defaultFloorplan,
   defineZone,
   engine,
   findsAnswer,