@adatechnology/game-floorplan 0.2.2 → 0.3.0

package/dist/index.global.js

@@ -30,11 +30,13 @@ var GameFloorplan = (() => {
     createCompanyHouse: () => createCompanyHouse,
     createDetachedHouse: () => createDetachedHouse,
     createFarmhouse: () => createFarmhouse,
+    createFloorplan: () => createFloorplan,
     createRng: () => createRng,
     createSilhouetteRandom: () => createSilhouetteRandom,
     createSlabHouse: () => createSlabHouse,
     createStiltHouse: () => createStiltHouse,
     createTwoStoreyHouse: () => createTwoStoreyHouse,
+    defaultFloorplan: () => defaultFloorplan,
     defineZone: () => defineZone,
     engine: () => engine,
     findsAnswer: () => findsAnswer,
@@ -79,137 +81,123 @@ var GameFloorplan = (() => {
     windowZone: () => windowZone
   });
 
-  // 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
@@ -289,7 +277,7 @@ var GameFloorplan = (() => {
     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 });
     }
   }
@@ -300,13 +288,45 @@ var GameFloorplan = (() => {
     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));
@@ -741,7 +761,7 @@ var GameFloorplan = (() => {
     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;
@@ -832,7 +852,7 @@ var GameFloorplan = (() => {
         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") {
@@ -909,7 +929,7 @@ var GameFloorplan = (() => {
       }
       return null;
     };
-    const process = (u) => {
+    const process2 = (u) => {
       const pr = u.members[0].chance;
       const x = rng();
       const arr = u.members.slice();
@@ -945,7 +965,7 @@ var GameFloorplan = (() => {
       let i = pending.findIndex(ready);
       if (i < 0) i = 0;
       const u = pending.splice(i, 1)[0];
-      process(u);
+      process2(u);
       for (const m of u.members) done.add(m.id);
     }
     return { items, missing };
@@ -983,9 +1003,9 @@ var GameFloorplan = (() => {
     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
   };
@@ -993,7 +1013,7 @@ var GameFloorplan = (() => {
     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(
         {
@@ -1039,9 +1059,9 @@ var GameFloorplan = (() => {
     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);
@@ -1120,7 +1140,7 @@ var GameFloorplan = (() => {
       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) {
@@ -1140,19 +1160,20 @@ var GameFloorplan = (() => {
   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;
   }
@@ -1281,22 +1302,20 @@ var GameFloorplan = (() => {
   }
 
   // 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;
     }
@@ -1342,7 +1361,7 @@ var GameFloorplan = (() => {
     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;
@@ -1380,14 +1399,14 @@ var GameFloorplan = (() => {
   }
   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" });
@@ -1620,9 +1639,9 @@ var GameFloorplan = (() => {
       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) {
@@ -1702,14 +1721,14 @@ var GameFloorplan = (() => {
       }
     }
     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) => {
@@ -1742,10 +1761,10 @@ var GameFloorplan = (() => {
     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;
   }
 
@@ -1795,8 +1814,8 @@ var GameFloorplan = (() => {
   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));
@@ -1814,14 +1833,14 @@ var GameFloorplan = (() => {
     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;
@@ -1831,7 +1850,7 @@ var GameFloorplan = (() => {
         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];
@@ -1885,8 +1904,8 @@ var GameFloorplan = (() => {
   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();
@@ -2076,8 +2095,8 @@ var GameFloorplan = (() => {
   // 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;
   }
@@ -2095,10 +2114,10 @@ var GameFloorplan = (() => {
     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) {
@@ -2108,13 +2127,13 @@ var GameFloorplan = (() => {
     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,
@@ -2124,8 +2143,8 @@ var GameFloorplan = (() => {
       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);
   }
@@ -2145,7 +2164,7 @@ var GameFloorplan = (() => {
     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);
     }
@@ -2258,7 +2277,7 @@ var GameFloorplan = (() => {
     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,
@@ -2275,6 +2294,101 @@ var GameFloorplan = (() => {
     });
   }
 
+  // ../game-contracts/dist/index.js
+  var DEFAULT_COST_ALLOCATION_BYTES = 1024 * 1024;
+  var DEFERRED_QUEUE_ID = {
+    DESTRUCTION_EVENTS: "destruction.events",
+    BREACH_PAINT: "floorplan.breach-paint",
+    AUDIO_VOICES: "audio.voices",
+    VEHICLE_CREASE: "vehicles.crease"
+  };
+  var DEFERRED_PRIORITY = {
+    [DEFERRED_QUEUE_ID.DESTRUCTION_EVENTS]: { priority: 300, phase: "present" },
+    [DEFERRED_QUEUE_ID.BREACH_PAINT]: { priority: 250, phase: "present" },
+    [DEFERRED_QUEUE_ID.AUDIO_VOICES]: { priority: 200, phase: "idle", reserveMs: 1 },
+    [DEFERRED_QUEUE_ID.VEHICLE_CREASE]: { priority: 100, phase: "idle" }
+  };
+  var WARNED_KEY = /* @__PURE__ */ Symbol.for("@adatechnology/game-contracts.warned");
+  var warnedKeys = () => {
+    const holder = globalThis;
+    return holder[WARNED_KEY] ?? (holder[WARNED_KEY] = /* @__PURE__ */ new Set());
+  };
+  var isProduction = () => {
+    try {
+      return process.env.NODE_ENV === "production";
+    } catch {
+      return false;
+    }
+  };
+  var isQuiet = () => globalThis.__GAME_KIT_QUIET__ === true;
+  var warnOnce = (key, message) => {
+    if (isQuiet() || isProduction()) return;
+    const seen = warnedKeys();
+    if (seen.has(key)) return;
+    seen.add(key);
+    console.warn(`[game-kit] ${message}`);
+  };
+  var UNSAFE_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+  var isPlainObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value) && Object.getPrototypeOf(value) === Object.prototype;
+  var deepMerge = (base, patch) => {
+    if (!patch) return base;
+    const result = { ...base };
+    for (const [key, value] of Object.entries(patch)) {
+      if (value === void 0 || UNSAFE_KEYS.has(key)) continue;
+      const current = result[key];
+      result[key] = isPlainObject(current) && isPlainObject(value) ? deepMerge(current, value) : value;
+    }
+    return result;
+  };
+  var applyPatches = (entries, patches) => {
+    for (const [id, patch] of Object.entries(patches ?? {})) {
+      const entry = entries.get(id);
+      if (entry) entries.set(id, deepMerge(entry, patch));
+      else warnOnce(`registry.patch.${id}`, `patch for "${id}" ignored: no entry has that id`);
+    }
+  };
+  var removeIds = (entries, ids) => {
+    for (const id of ids ?? []) {
+      if (!entries.delete(id)) warnOnce(`registry.remove.${id}`, `remove of "${id}" ignored: no entry has that id`);
+    }
+  };
+  var SURFACE_IDS = ["concrete", "asphalt", "wood", "tile", "dirt", "grass", "gravel", "sand", "metal", "water", "glass", "carpet"];
+  var GAIT_IDS = ["walk", "run"];
+  var LANDING_IDS = ["light", "heavy"];
+  var BODY_SOUND_IDS = [
+    "jump",
+    "cloth_rustle",
+    "body_fall",
+    "fall_damage",
+    "player_hurt",
+    "player_breath_run",
+    "player_death",
+    "bite",
+    "grab",
+    "punch_swing",
+    "punch_hit_body",
+    "punch_hit_face",
+    "punch_hit_object",
+    "kick_swing",
+    "kick_hit",
+    "kick_hit_object",
+    "shove_two_hands",
+    "knife_swing",
+    "knife_stab",
+    "knife_slash",
+    "knife_hit_object",
+    "blunt_swing",
+    "blunt_hit",
+    "blunt_hit_object",
+    "axe_swing",
+    "axe_chop",
+    "axe_hit_object"
+  ];
+  var footstepSoundId = (surface, gait) => `footstep_${surface}_${gait}`;
+  var FOOTSTEP_SOUND_IDS = SURFACE_IDS.flatMap((surface) => GAIT_IDS.map((gait) => footstepSoundId(surface, gait)));
+  var LAND_SOUND_IDS = SURFACE_IDS.flatMap((surface) => LANDING_IDS.map((landing) => `land_${surface}_${landing}`));
+  var BODY_FOLEY_IDS = [...FOOTSTEP_SOUND_IDS, ...LAND_SOUND_IDS, ...BODY_SOUND_IDS];
+
   // src/ground-items.ts
   function registerGroundItems() {
     const flat = { category: "ground_cover", w: 1, d: 1, h: 0, decor: true, mount: "ground", flat: true };
@@ -2495,6 +2609,109 @@ var GameFloorplan = (() => {
     }
   };
 
+  // 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;
@@ -2704,68 +2921,7 @@ var GameFloorplan = (() => {
   }
 
   // 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();
   return __toCommonJS(index_exports);
 })();
 //# sourceMappingURL=index.global.js.map