@adatechnology/game-interactables 0.0.0-stage → 0.2.0

package/dist/index.js

@@ -0,0 +1,1740 @@
+// src/colliders.ts
+var volume = (b) => (b.u1 - b.u0) * (b.v1 - b.v0) * (b.y1 - b.y0);
+var overlap = (a0, a1, b0, b1) => Math.max(0, Math.min(a1, b1) - Math.max(a0, b0));
+function tryMerge(a, b, gap, slack) {
+  if (a.u0 - gap > b.u1 || b.u0 - gap > a.u1) return null;
+  if (a.v0 - gap > b.v1 || b.v0 - gap > a.v1) return null;
+  if (a.y0 - gap > b.y1 || b.y0 - gap > a.y1) return null;
+  const u0 = Math.min(a.u0, b.u0);
+  const u1 = Math.max(a.u1, b.u1);
+  const v0 = Math.min(a.v0, b.v0);
+  const v1 = Math.max(a.v1, b.v1);
+  const y0 = Math.min(a.y0, b.y0);
+  const y1 = Math.max(a.y1, b.y1);
+  const hull = (u1 - u0) * (v1 - v0) * (y1 - y0);
+  const common = overlap(a.u0, a.u1, b.u0, b.u1) * overlap(a.v0, a.v1, b.v0, b.v1) * overlap(a.y0, a.y1, b.y0, b.y1);
+  const real = volume(a) + volume(b) - common;
+  if (hull > real * (1 + slack) + 1e-9) return null;
+  return { ids: [...a.ids, ...b.ids], object: a.object, u0, u1, v0, v1, y0, y1 };
+}
+function mergeColliders(list, options = {}) {
+  const gap = options.gap ?? 0.02;
+  const slack = options.slack ?? 0.1;
+  const groups = /* @__PURE__ */ new Map();
+  for (const c of list) {
+    const key = `${c.object}|${Math.round(c.ry * 1e3)}`;
+    const g = groups.get(key);
+    if (g) g.push(c);
+    else groups.set(key, [c]);
+  }
+  const out = [];
+  for (const g of groups.values()) {
+    const ry = g[0]?.ry ?? 0;
+    const cs = Math.cos(ry);
+    const sn = Math.sin(ry);
+    let boxes = g.map((c) => {
+      const u = c.cx * cs - c.cz * sn;
+      const v = c.cx * sn + c.cz * cs;
+      return { ids: [c.id], object: c.object, u0: u - c.hw, u1: u + c.hw, v0: v - c.hd, v1: v + c.hd, y0: c.y0, y1: c.y1 };
+    });
+    let changed = boxes.length > 1;
+    while (changed) {
+      changed = false;
+      outer: for (let i = 0; i < boxes.length; i++) {
+        for (let j = i + 1; j < boxes.length; j++) {
+          const m = tryMerge(boxes[i], boxes[j], gap, slack);
+          if (!m) continue;
+          boxes = boxes.filter((_, k) => k !== i && k !== j);
+          boxes.push(m);
+          changed = true;
+          break outer;
+        }
+      }
+    }
+    for (const b of boxes) {
+      const u = (b.u0 + b.u1) / 2;
+      const v = (b.v0 + b.v1) / 2;
+      out.push({
+        id: b.ids.length === 1 ? b.ids[0] : `${b.ids[0]}+${b.ids.length - 1}`,
+        object: b.object,
+        cx: u * cs + v * sn,
+        cz: -u * sn + v * cs,
+        hw: (b.u1 - b.u0) / 2,
+        hd: (b.v1 - b.v0) / 2,
+        ry,
+        y0: b.y0,
+        y1: b.y1
+      });
+    }
+  }
+  return out;
+}
+
+// src/rng.ts
+function hashString(text) {
+  let h = 2166136261;
+  for (let i = 0; i < text.length; i++) {
+    h ^= text.charCodeAt(i);
+    h = Math.imul(h, 16777619);
+  }
+  return h >>> 0;
+}
+function rng(seed = 1) {
+  let a = (typeof seed === "number" ? Math.floor(seed) >>> 0 : hashString(seed)) || 2654435769;
+  return () => {
+    a = a + 1831565813 >>> 0;
+    let t = a;
+    t = Math.imul(t ^ t >>> 15, t | 1);
+    t ^= t + Math.imul(t ^ t >>> 7, t | 61);
+    return ((t ^ t >>> 14) >>> 0) / 4294967296;
+  };
+}
+
+// src/loot.ts
+function fitsSize(size, max) {
+  const eps = 1e-9;
+  if (size[1] > max[1] + eps) return false;
+  return size[0] <= max[0] + eps && size[2] <= max[2] + eps || size[2] <= max[0] + eps && size[0] <= max[2] + eps;
+}
+function fitsSlot(type, slot, items) {
+  const def = items?.[type];
+  return def ? fitsSize(def.size, slot.max) : true;
+}
+function generateLoot(tables, tableId, slots, seed, items) {
+  const table = tables?.[tableId];
+  const out = slots.map(() => null);
+  if (!table) return out;
+  const rand = rng(seed);
+  slots.forEach((slot, i) => {
+    const roll = rand();
+    const pick = rand();
+    const q = rand();
+    if (roll >= table.fill) return;
+    const candidates = table.entries.filter((e) => e.weight > 0 && fitsSlot(e.type, slot, items));
+    const total = candidates.reduce((s, e) => s + e.weight, 0);
+    if (total <= 0) return;
+    let r = pick * total;
+    let chosen = candidates[candidates.length - 1];
+    for (const e of candidates) {
+      r -= e.weight;
+      if (r < 0) {
+        chosen = e;
+        break;
+      }
+    }
+    const [lo, hi] = chosen.qty ?? [1, 1];
+    const def = items?.[chosen.type];
+    const stackMax = def ? def.stack ?? 1 : Number.POSITIVE_INFINITY;
+    const qty = Math.max(1, Math.min(stackMax, lo + Math.floor(q * (hi - lo + 1))));
+    out[i] = { type: chosen.type, qty };
+  });
+  return out;
+}
+
+// src/locale.ts
+var locales = {
+  en: {
+    "prompt.open": "Open {name}",
+    "prompt.close": "Close {name}",
+    "prompt.turn_on": "Turn on {name}",
+    "prompt.turn_off": "Turn off {name}",
+    "prompt.take": "Take",
+    "prompt.sit": "Sit",
+    "prompt.lie_down": "Lie down",
+    "prompt.get_up": "Get up",
+    "prompt.light": "Light",
+    "prompt.change_channel": "Change channel",
+    "prompt.read": "Read",
+    "prompt.breaker_on": "Switch on {circuit}",
+    "prompt.breaker_off": "Switch off {circuit}",
+    "prompt.open_valve": "Open valve",
+    "prompt.close_valve": "Close valve",
+    no_power: "No power",
+    no_gas: "No gas",
+    no_water: "No water",
+    locked: "Locked",
+    requires_open: "Open it first",
+    already_lit: "Already lit",
+    needs_ignition: "Light it first",
+    turn_on_first: "Turn it on first",
+    empty: "Empty",
+    full: "Full"
+  },
+  "pt-BR": {
+    "prompt.open": "Abrir {name}",
+    "prompt.close": "Fechar {name}",
+    "prompt.turn_on": "Ligar {name}",
+    "prompt.turn_off": "Desligar {name}",
+    "prompt.take": "Pegar",
+    "prompt.sit": "Sentar",
+    "prompt.lie_down": "Deitar",
+    "prompt.get_up": "Levantar",
+    "prompt.light": "Acender",
+    "prompt.change_channel": "Trocar de canal",
+    "prompt.read": "Ler",
+    "prompt.breaker_on": "Ligar {circuit}",
+    "prompt.breaker_off": "Desligar {circuit}",
+    "prompt.open_valve": "Abrir registro",
+    "prompt.close_valve": "Fechar registro",
+    no_power: "Sem energia",
+    no_gas: "Sem g\xE1s",
+    no_water: "Sem \xE1gua",
+    locked: "Trancado",
+    requires_open: "Abra primeiro",
+    already_lit: "J\xE1 est\xE1 aceso",
+    needs_ignition: "Acenda primeiro",
+    turn_on_first: "Ligue primeiro",
+    empty: "Vazio",
+    full: "Cheio"
+  }
+};
+function pickLocale(locale) {
+  if (!locale) return "en";
+  const l = locale.toLowerCase();
+  if (l === "pt-br" || l === "pt") return "pt-BR";
+  return "en";
+}
+function resolveStrings(locale, extra) {
+  const loc = pickLocale(locale);
+  return { ...locales.en, ...locales[loc], ...extra?.en ?? {}, ...loc === "en" ? {} : extra?.[loc] ?? {} };
+}
+function format(text, vars) {
+  if (!vars) return text;
+  return text.replace(/\{(\w+)\}/g, (m, k) => k in vars ? String(vars[k]) : m);
+}
+
+// src/math.ts
+var DEFAULT_AXIS = [0, 1, 0];
+function poseOf(motion, t) {
+  const tt = Math.max(0, Math.min(1, t));
+  const axis = motion.axis ?? DEFAULT_AXIS;
+  const pose = { position: [0, 0, 0], rotation: { axis: [axis[0], axis[1], axis[2]], angle: 0 }, scale: [1, 1, 1] };
+  switch (motion.kind) {
+    case "hinge":
+    case "rocker":
+    case "knob":
+      pose.rotation.angle = (motion.angle ?? Math.PI / 2) * tt;
+      break;
+    case "slide": {
+      const d = (motion.distance ?? 0.4) * tt;
+      pose.position = [axis[0] * d, axis[1] * d, axis[2] * d];
+      break;
+    }
+    case "scale": {
+      const k = 1 + ((motion.scale ?? 0.2) - 1) * tt;
+      pose.scale = [axis[0] !== 0 ? k : 1, axis[1] !== 0 ? k : 1, axis[2] !== 0 ? k : 1];
+      break;
+    }
+  }
+  return pose;
+}
+function rotY(v, ry) {
+  const c = Math.cos(ry);
+  const s = Math.sin(ry);
+  return [c * v[0] + s * v[2], v[1], -s * v[0] + c * v[2]];
+}
+function localToWorld(transform, v) {
+  const r = rotY(v, transform.ry);
+  return [transform.x + r[0], transform.y + r[1], transform.z + r[2]];
+}
+function worldToLocal(transform, v) {
+  return rotY([v[0] - transform.x, v[1] - transform.y, v[2] - transform.z], -transform.ry);
+}
+function rotateAxis(v, axis, angle) {
+  const len = Math.hypot(axis[0], axis[1], axis[2]) || 1;
+  const k = [axis[0] / len, axis[1] / len, axis[2] / len];
+  const c = Math.cos(angle);
+  const s = Math.sin(angle);
+  const dot = k[0] * v[0] + k[1] * v[1] + k[2] * v[2];
+  const cross = [k[1] * v[2] - k[2] * v[1], k[2] * v[0] - k[0] * v[2], k[0] * v[1] - k[1] * v[0]];
+  return [v[0] * c + cross[0] * s + k[0] * dot * (1 - c), v[1] * c + cross[1] * s + k[1] * dot * (1 - c), v[2] * c + cross[2] * s + k[2] * dot * (1 - c)];
+}
+function clamp(v, lo, hi) {
+  return v < lo ? lo : v > hi ? hi : v;
+}
+function dist3(a, b) {
+  return Math.hypot(a[0] - b[0], a[1] - b[1], a[2] - b[2]);
+}
+
+// src/world.ts
+var DEFAULT_ACTOR = "player";
+var DEFAULT_RADIUS = 1.2;
+var AUTO_RANGE = 2;
+var SMOKE_TAIL = 20;
+var FLUSH_SECONDS = 2;
+var ACTOR_HEIGHT = 1.7;
+var PUSH_GAIN = 1.2;
+var SWEEP_STEPS = 24;
+var FLOW_DEFAULTS = { tap: 6, shower: 8, utility_sink: 6, flush: 0, hose: 10, filter: 1 };
+function cloneStack(s) {
+  return s ? { type: s.type, qty: s.qty, ...s.data ? { data: JSON.parse(JSON.stringify(s.data)) } : {} } : null;
+}
+function humanize(id) {
+  const s = id.replace(/[_-]+/g, " ").trim();
+  return s.charAt(0).toUpperCase() + s.slice(1);
+}
+function createWorld(options = {}) {
+  const seed = options.seed ?? 1;
+  const objs = /* @__PURE__ */ new Map();
+  const breakers = /* @__PURE__ */ new Map();
+  const seats = /* @__PURE__ */ new Map();
+  const plugs = /* @__PURE__ */ new Map();
+  let locale = options.locale ?? "en";
+  let table = resolveStrings(locale, options.strings);
+  let grid = options.grid ?? true;
+  let rain = options.rain ?? 0;
+  let wind = options.wind ? [options.wind[0], options.wind[1]] : [0, 0];
+  let defaultTank = null;
+  let defaultTankExplicit = false;
+  let time = 0;
+  function t(key, vars) {
+    return format(table[key] ?? key, vars);
+  }
+  function emit(e) {
+    options.onEvent?.(e);
+  }
+  function message(key) {
+    emit({ type: "message", key, text: t(key) });
+  }
+  function gid(o, local) {
+    return `${o.id}:${local}`;
+  }
+  function findGlobal(id, pick) {
+    for (const o of objs.values()) {
+      if (!id.startsWith(o.id + ":")) continue;
+      const local = id.slice(o.id.length + 1);
+      const value = pick(o, local);
+      if (value !== void 0) return { o, value, local };
+    }
+    return null;
+  }
+  function objectOrThrow(id) {
+    const o = objs.get(id);
+    if (!o) throw new Error(`Unknown object "${id}"`);
+    return o;
+  }
+  function originOf(o) {
+    const tr = o.public.transform;
+    return [tr.x, tr.y, tr.z];
+  }
+  function toWorld(o, v) {
+    return localToWorld(o.public.transform, v);
+  }
+  function openThreshold(p) {
+    return Math.min(0.5, p.maxT * 0.9);
+  }
+  function isOpen(o, partId) {
+    if (!partId) return true;
+    const p = o.parts.get(partId);
+    if (!p) return true;
+    return p.maxT >= 0.1 && p.t >= openThreshold(p);
+  }
+  function targetIsOpen(p) {
+    return p.maxT >= 0.1 && p.target >= openThreshold(p);
+  }
+  function writeT(o, p, v) {
+    p.t = v;
+    o.public.parts[p.spec.id] = v;
+  }
+  function gated(o, p) {
+    return !!p.spec.requires && o.parts.has(p.spec.requires) && !isOpen(o, p.spec.requires);
+  }
+  function setOnePart(o, p, target2, instant) {
+    const next = clamp(target2, 0, p.maxT);
+    const changed = next !== p.target;
+    p.target = next;
+    if (instant) writeT(o, p, next);
+    if (changed || instant) emit({ type: "part", object: o.id, part: p.spec.id, t: p.t, target: p.target });
+  }
+  function setPartTarget(o, partId, target2, instant = false) {
+    const p = o.parts.get(partId);
+    if (!p) return;
+    const group = p.spec.group;
+    const members = group ? [...o.parts.values()].filter((q) => q.spec.group === group) : [p];
+    for (const q of members) {
+      setOne(o, q, target2, instant);
+    }
+  }
+  function setOne(o, p, target2, instant) {
+    setOnePart(o, p, target2, instant);
+    if (!targetIsOpen(p)) {
+      for (const q of o.parts.values()) {
+        if (q.spec.requires === p.spec.id && q.target > 0) setPartTarget(o, q.spec.id, 0, instant);
+      }
+    }
+  }
+  function partFrame(o, partId) {
+    if (!partId) return null;
+    const p = o.parts.get(partId);
+    if (!p) return null;
+    const m = p.spec.motion;
+    const axis = rotY(m.axis ?? [0, 1, 0], p.spec.ry ?? 0);
+    const frame = { pivot: p.spec.pivot, axis, angle: 0, offset: [0, 0, 0] };
+    if (m.kind === "slide") {
+      const d = (m.distance ?? 0.4) * p.t;
+      frame.offset = [axis[0] * d, axis[1] * d, axis[2] * d];
+    } else if (m.kind !== "scale") {
+      frame.angle = (m.angle ?? Math.PI / 2) * p.t;
+    }
+    return frame;
+  }
+  function applyPart(o, partId, local) {
+    const f = partFrame(o, partId);
+    if (!f) return local;
+    const rel = [local[0] - f.pivot[0], local[1] - f.pivot[1], local[2] - f.pivot[2]];
+    const r = f.angle !== 0 ? rotateAxis(rel, f.axis, f.angle) : rel;
+    return [f.pivot[0] + r[0] + f.offset[0], f.pivot[1] + r[1] + f.offset[1], f.pivot[2] + r[2] + f.offset[2]];
+  }
+  function fitBounds(o, p, b, blockedAt) {
+    const STEP = 0.05;
+    const ANGLES = 48;
+    const m = p.spec.motion;
+    const axis = rotY(m.axis ?? [0, 1, 0], p.spec.ry ?? 0);
+    const lo = [Math.min(b[0], b[3]), Math.min(b[1], b[4]), Math.min(b[2], b[5])];
+    const hi = [Math.max(b[0], b[3]), Math.max(b[1], b[4]), Math.max(b[2], b[5])];
+    const axisPoints = (i) => {
+      const n = Math.max(1, Math.ceil((hi[i] - lo[i]) / STEP));
+      return Array.from({ length: n + 1 }, (_, k) => lo[i] + (hi[i] - lo[i]) * k / n);
+    };
+    const xs = axisPoints(0);
+    const ys = axisPoints(1);
+    const zs = axisPoints(2);
+    const flat = m.kind === "slide" || Math.abs(axis[1]) > 0.999;
+    const seen = /* @__PURE__ */ new Set();
+    const pts = [];
+    const add2 = (x, y, z) => {
+      const key = `${x.toFixed(5)},${y.toFixed(5)},${z.toFixed(5)}`;
+      if (seen.has(key)) return;
+      seen.add(key);
+      pts.push([x, y, z]);
+    };
+    if (flat) {
+      for (const x of xs) for (const z of [lo[2], hi[2]]) add2(x, lo[1], z);
+      for (const z of zs) for (const x of [lo[0], hi[0]]) add2(x, lo[1], z);
+    } else {
+      for (const x of xs) for (const y of [lo[1], hi[1]]) for (const z of [lo[2], hi[2]]) add2(x, y, z);
+      for (const y of ys) for (const x of [lo[0], hi[0]]) for (const z of [lo[2], hi[2]]) add2(x, y, z);
+      for (const z of zs) for (const x of [lo[0], hi[0]]) for (const y of [lo[1], hi[1]]) add2(x, y, z);
+    }
+    const tr = o.public.transform;
+    const pivot = p.spec.pivot;
+    for (let i = 1; i <= ANGLES; i++) {
+      const tt = i / ANGLES;
+      const angle = m.kind === "slide" ? 0 : (m.angle ?? Math.PI / 2) * tt;
+      const d = m.kind === "slide" ? (m.distance ?? 0.4) * tt : 0;
+      for (const [x, y, z] of pts) {
+        let q = [x, y, z];
+        if (angle !== 0) {
+          const r = rotateAxis([x - pivot[0], y - pivot[1], z - pivot[2]], axis, angle);
+          q = [pivot[0] + r[0], pivot[1] + r[1], pivot[2] + r[2]];
+        }
+        const w = localToWorld(tr, [q[0] + axis[0] * d, 0, q[2] + axis[2] * d]);
+        if (blockedAt(w[0], w[2])) return (i - 1) / ANGLES;
+      }
+    }
+    return 1;
+  }
+  function fitSweep(objectId, partId, blocked) {
+    const o = objectOrThrow(objectId);
+    const p = o.parts.get(partId);
+    if (!p) throw new Error(`Unknown part "${partId}" on "${objectId}"`);
+    const sweep = p.spec.sweep;
+    let result = 1;
+    const bounds = p.spec.bounds;
+    const mk = p.spec.motion.kind;
+    if (bounds && (mk === "hinge" || mk === "rocker" || mk === "knob" || mk === "slide")) {
+      result = fitBounds(o, p, bounds, blocked);
+    } else if (sweep) {
+      const x0 = Math.min(sweep[0], sweep[2]);
+      const x1 = Math.max(sweep[0], sweep[2]);
+      const z0 = Math.min(sweep[1], sweep[3]);
+      const z1 = Math.max(sweep[1], sweep[3]);
+      const tr = o.public.transform;
+      const hit = (lx, lz) => {
+        const w = localToWorld(tr, [lx, 0, lz]);
+        return blocked(w[0], w[2]);
+      };
+      const m = p.spec.motion;
+      const axis = rotY(m.axis ?? [0, 1, 0], p.spec.ry ?? 0);
+      if (m.kind === "hinge" || m.kind === "rocker" || m.kind === "knob") {
+        if (Math.abs(axis[1]) >= 0.5) {
+          const angle = m.angle ?? Math.PI / 2;
+          const total = -angle * Math.sign(axis[1]);
+          const [px, , pz] = p.spec.pivot;
+          const cx = (x0 + x1) / 2;
+          const cz = (z0 + z1) / 2;
+          const w = x1 - x0;
+          const d = z1 - z0;
+          const radius = Math.abs(angle) > 1.7 ? Math.min(w, d) : Math.max(w, d);
+          const tol = 0.05;
+          const inRect = (x, z) => x >= x0 - tol && x <= x1 + tol && z >= z0 - tol && z <= z1 + tol;
+          const centered = Math.hypot(cx - px, cz - pz) < 1e-6;
+          const mid = Math.atan2(cz - pz, cx - px);
+          for (let i = 1; i <= SWEEP_STEPS && result === 1; i++) {
+            const tt = i / SWEEP_STEPS;
+            let isHit = false;
+            if (centered) {
+              for (let x = x0; x <= x1 + 1e-9 && !isHit; x += 0.1) for (let z = z0; z <= z1 + 1e-9 && !isHit; z += 0.1) isHit = hit(x, z);
+            } else {
+              const phi = mid - total / 2 + total * tt;
+              const steps = Math.max(2, Math.ceil(radius / 0.1));
+              for (let k = 1; k <= steps && !isHit; k++) {
+                const r = radius * k / steps;
+                const x = px + Math.cos(phi) * r;
+                const z = pz + Math.sin(phi) * r;
+                if (inRect(x, z)) isHit = hit(x, z);
+              }
+            }
+            if (isHit) result = (i - 1) / SWEEP_STEPS;
+          }
+        }
+      } else if (m.kind === "slide") {
+        const len = Math.hypot(axis[0], axis[2]);
+        if (len > 1e-6) {
+          const dx = axis[0] / len;
+          const dz = axis[2] / len;
+          const proj = [x0 * dx + z0 * dz, x1 * dx + z0 * dz, x0 * dx + z1 * dz, x1 * dx + z1 * dz];
+          const pmin = Math.min(...proj);
+          const pmax = Math.max(...proj);
+          const nx = Math.max(1, Math.ceil((x1 - x0) / 0.1));
+          const nz = Math.max(1, Math.ceil((z1 - z0) / 0.1));
+          for (let i = 1; i <= SWEEP_STEPS && result === 1; i++) {
+            const limit = pmin + (pmax - pmin) * (i / SWEEP_STEPS);
+            let isHit = false;
+            for (let a = 0; a <= nx && !isHit; a++) {
+              for (let b = 0; b <= nz && !isHit; b++) {
+                const x = x0 + (x1 - x0) * a / nx;
+                const z = z0 + (z1 - z0) * b / nz;
+                if (x * dx + z * dz <= limit + 1e-9 && hit(x, z)) isHit = true;
+              }
+            }
+            if (isHit) result = (i - 1) / SWEEP_STEPS;
+          }
+        }
+      }
+    }
+    p.maxT = result;
+    if (p.target > result) p.target = result;
+    if (p.t > result) writeT(o, p, result);
+    return result;
+  }
+  function containerOf(o, id) {
+    return o.spec.containers?.find((c) => c.id === id);
+  }
+  function accessible(objectId, containerId) {
+    const o = objs.get(objectId);
+    if (!o) return false;
+    const c = containerOf(o, containerId);
+    if (!c) return false;
+    return isOpen(o, c.access);
+  }
+  function contents(objectId, containerId) {
+    return (objs.get(objectId)?.contents.get(containerId) ?? []).map(cloneStack);
+  }
+  function take(objectId, containerId, slot, actor = DEFAULT_ACTOR) {
+    const o = objs.get(objectId);
+    if (!o) return null;
+    const list = o.contents.get(containerId);
+    if (!list || !accessible(objectId, containerId)) return null;
+    const stack = list[slot];
+    if (!stack) return null;
+    const def = options.items?.[stack.type];
+    if (def && def.pickable === false) return null;
+    list[slot] = null;
+    emit({ type: "pickup", object: objectId, container: containerId, slot, stack: cloneStack(stack), actor });
+    return stack;
+  }
+  function put(objectId, containerId, stack) {
+    const o = objs.get(objectId);
+    if (!o) return null;
+    const c = containerOf(o, containerId);
+    const list = o.contents.get(containerId);
+    if (!c || !list || !accessible(objectId, containerId)) return null;
+    const maxStack = options.items?.[stack.type]?.stack ?? 1;
+    for (let i = 0; i < list.length; i++) {
+      const cur = list[i];
+      if (cur && cur.type === stack.type && !cur.data && !stack.data && cur.qty + stack.qty <= maxStack) {
+        cur.qty += stack.qty;
+        return i;
+      }
+    }
+    for (let i = 0; i < list.length; i++) {
+      if (!list[i] && fitsSlot(stack.type, c.slots[i], options.items)) {
+        list[i] = cloneStack(stack);
+        return i;
+      }
+    }
+    message("full");
+    return null;
+  }
+  function slotPosition(objectId, containerId, slot) {
+    const o = objectOrThrow(objectId);
+    const c = containerOf(o, containerId);
+    const s = c?.slots[slot];
+    if (!c || !s) throw new Error(`Unknown slot ${slot} of "${containerId}" on "${objectId}"`);
+    return toWorld(o, applyPart(o, s.part, s.pos));
+  }
+  function rebuildPlugs() {
+    plugs.clear();
+    const sockets = [];
+    for (const o of objs.values()) {
+      for (const s of o.spec.sockets ?? []) sockets.push({ id: gid(o, s.id), local: s.id, pos: toWorld(o, s.pos), circuit: s.circuit });
+    }
+    const used = /* @__PURE__ */ new Set();
+    const autos = [];
+    for (const o of objs.values()) {
+      for (const d of o.devices.values()) {
+        const key = gid(o, d.spec.id);
+        const want = d.spec.socket;
+        if (want === void 0 || d.spec.circuit) {
+          plugs.set(key, null);
+        } else if (want === "auto") {
+          plugs.set(key, null);
+          autos.push({ o, d });
+        } else {
+          const s = sockets.find((x) => x.id === want) ?? sockets.find((x) => x.id === gid(o, want)) ?? sockets.find((x) => x.local === want);
+          plugs.set(key, s ? s.id : null);
+          if (s) used.add(s.id);
+        }
+      }
+    }
+    for (const { o, d } of autos) {
+      const from = d.spec.plug ? toWorld(o, d.spec.plug) : originOf(o);
+      let best = null;
+      let bestD = AUTO_RANGE;
+      for (const s of sockets) {
+        if (used.has(s.id)) continue;
+        const dd = dist3(from, s.pos);
+        if (dd <= bestD) {
+          best = s;
+          bestD = dd;
+        }
+      }
+      if (best) {
+        used.add(best.id);
+        plugs.set(gid(o, d.spec.id), best.id);
+      }
+    }
+  }
+  function breaker(circuit) {
+    return breakers.get(circuit) ?? true;
+  }
+  function devicePowered(o, d) {
+    if (d.spec.electric === false) return true;
+    if (!grid) return false;
+    if (d.spec.circuit) return breaker(d.spec.circuit);
+    if (d.spec.socket === void 0) return false;
+    const sid = plugs.get(gid(o, d.spec.id));
+    if (!sid) return false;
+    const found = findGlobal(sid, (oo, local) => oo.spec.sockets?.find((s) => s.id === local));
+    if (!found) return false;
+    return found.value.circuit ? breaker(found.value.circuit) : true;
+  }
+  function getDevice(objectId, deviceId) {
+    const o = objs.get(objectId);
+    const d = o?.devices.get(deviceId);
+    return o && d ? { o, d } : null;
+  }
+  function powerSnapshot() {
+    const m = /* @__PURE__ */ new Map();
+    for (const o of objs.values()) for (const d of o.devices.values()) m.set(gid(o, d.spec.id), d.on && devicePowered(o, d));
+    return m;
+  }
+  function emitPowerChanges(before) {
+    for (const o of objs.values()) {
+      for (const d of o.devices.values()) {
+        const key = gid(o, d.spec.id);
+        const now = d.on && devicePowered(o, d);
+        if (before.get(key) !== now && d.on) emit({ type: "device", object: o.id, device: d.spec.id, on: d.on, powered: devicePowered(o, d), channel: d.spec.kind === "screen" ? d.channel : void 0 });
+      }
+    }
+  }
+  function setDeviceOn(o, d, on) {
+    d.on = on;
+    if (d.spec.part) setPartTarget(o, d.spec.part, on ? 1 : 0);
+    const powered = devicePowered(o, d);
+    emit({ type: "device", object: o.id, device: d.spec.id, on, powered, channel: d.spec.kind === "screen" ? d.channel : void 0 });
+    if (on && !powered) message("no_power");
+  }
+  function setDevice(objectId, deviceId, on) {
+    const f = getDevice(objectId, deviceId);
+    if (!f) return false;
+    if (f.d.on !== on) setDeviceOn(f.o, f.d, on);
+    return true;
+  }
+  function setFixture(objectId, fixtureId, on) {
+    const fx = objs.get(objectId)?.fixtures.get(fixtureId);
+    if (!fx) return false;
+    if (fx.on !== on) toggleFixture(objs.get(objectId), fixtureId);
+    return fx.on === on;
+  }
+  function setBurner(objectId, burnerId, on) {
+    const o = objs.get(objectId);
+    const b = o?.burners.get(burnerId);
+    if (!o || !b) return false;
+    const isOn = b.on || b.lit;
+    if (on === isOn) return true;
+    if (!on) return toggleBurner(o, burnerId);
+    return b.spec.needsIgnition ? ignite(o, burnerId) : toggleBurner(o, burnerId);
+  }
+  function resolveDevice(o, id) {
+    if (id.includes(":")) {
+      const f = findGlobal(id, (oo, local2) => oo.devices.get(local2));
+      return f ? { o: f.o, d: f.value } : null;
+    }
+    const local = o.devices.get(id);
+    if (local) return { o, d: local };
+    for (const oo of objs.values()) {
+      const d = oo.devices.get(id);
+      if (d) return { o: oo, d };
+    }
+    return null;
+  }
+  function switchIsOn(o, spec) {
+    if (spec.part && o.parts.has(spec.part)) return targetIsOpen(o.parts.get(spec.part));
+    return spec.controls.some((id) => resolveDevice(o, id)?.d.on);
+  }
+  function toggleSwitch(o, id) {
+    const sw = o.spec.switches?.find((s) => s.id === id);
+    if (!sw) return false;
+    const on = !switchIsOn(o, sw);
+    if (sw.part) setPartTarget(o, sw.part, on ? 1 : 0);
+    let unpowered = false;
+    for (const ref of sw.controls) {
+      const r = resolveDevice(o, ref);
+      if (!r) continue;
+      r.d.on = on;
+      if (r.d.spec.part) setPartTarget(r.o, r.d.spec.part, on ? 1 : 0);
+      const powered = devicePowered(r.o, r.d);
+      if (on && !powered) unpowered = true;
+      emit({ type: "device", object: r.o.id, device: r.d.spec.id, on, powered });
+    }
+    emit({ type: "switch", object: o.id, switch: sw.id, on });
+    if (unpowered) message("no_power");
+    return true;
+  }
+  function resolveFuel(o, b) {
+    const want = b.spec.fuel;
+    if (want === "auto") {
+      const from = toWorld(o, b.spec.pos);
+      let best = null;
+      let bestD = AUTO_RANGE;
+      for (const oo of objs.values()) {
+        for (const f of oo.fuels.values()) {
+          if (f.spec.kind !== "gas") continue;
+          const d = dist3(from, originOf(oo));
+          if (d <= bestD) {
+            best = { o: oo, f };
+            bestD = d;
+          }
+        }
+      }
+      return best;
+    }
+    if (want.includes(":")) {
+      const f = findGlobal(want, (oo, local2) => oo.fuels.get(local2));
+      return f ? { o: f.o, f: f.value } : null;
+    }
+    const local = o.fuels.get(want);
+    return local ? { o, f: local } : null;
+  }
+  function valveOpen(o, f) {
+    const v = f.spec.valve;
+    if (!v || !o.parts.has(v)) return true;
+    return targetIsOpen(o.parts.get(v));
+  }
+  function canBurn(b, ref) {
+    return !!ref && ref.f.level > 0 && valveOpen(ref.o, ref.f);
+  }
+  function isSolid(ref) {
+    return !!ref && ref.f.spec.kind !== "gas";
+  }
+  function emitBurner(o, b) {
+    emit({ type: "burner", object: o.id, burner: b.spec.id, on: b.on, lit: b.lit });
+  }
+  function extinguish(o, b, turnOff) {
+    const ref = resolveFuel(o, b);
+    const wasLit = b.lit;
+    b.lit = false;
+    if (turnOff) b.on = false;
+    if (b.spec.part) setPartTarget(o, b.spec.part, b.on ? 1 : 0);
+    if (wasLit && isSolid(ref)) b.smoke = SMOKE_TAIL;
+    emitBurner(o, b);
+  }
+  function toggleBurner(o, id) {
+    const b = o.burners.get(id);
+    if (!b) return false;
+    if (b.on || b.lit) {
+      extinguish(o, b, true);
+      return true;
+    }
+    if (b.spec.needsIgnition) return false;
+    const ref = resolveFuel(o, b);
+    b.on = true;
+    b.lit = canBurn(b, ref);
+    if (b.lit) b.smoke = 0;
+    if (b.spec.part) setPartTarget(o, b.spec.part, 1);
+    emitBurner(o, b);
+    if (!b.lit) message(ref && ref.f.level <= 0 ? "empty" : "no_gas");
+    return true;
+  }
+  function ignite(o, id) {
+    const b = o.burners.get(id);
+    if (!b || b.lit) return false;
+    const ref = resolveFuel(o, b);
+    if (!canBurn(b, ref)) {
+      message(ref && ref.f.level <= 0 ? "empty" : "no_gas");
+      return false;
+    }
+    b.on = true;
+    b.lit = true;
+    b.smoke = 0;
+    if (b.spec.part) setPartTarget(o, b.spec.part, 1);
+    emitBurner(o, b);
+    return true;
+  }
+  function toggleFuel(o, id) {
+    const f = o.fuels.get(id);
+    if (!f || !f.spec.valve || !o.parts.has(f.spec.valve)) return false;
+    const p = o.parts.get(f.spec.valve);
+    setPartTarget(o, f.spec.valve, targetIsOpen(p) ? 0 : 1);
+    return true;
+  }
+  function resolveTank(o, id) {
+    const want = id === void 0 || id === "auto" ? defaultTank : id;
+    if (!want) return null;
+    const f = findGlobal(want, (oo, local2) => oo.tanks.get(local2));
+    if (f) return { o: f.o, t: f.value };
+    const local = o.tanks.get(want);
+    return local ? { o, t: local } : null;
+  }
+  function drawWater(o, fx, liters) {
+    if (liters <= 0) return 0;
+    if (options.waterSupply) return Math.max(0, Math.min(liters, options.waterSupply.draw(gid(o, fx.spec.id), liters)));
+    const tank = resolveTank(o, fx.spec.tank);
+    if (!tank) return 0;
+    const got = Math.min(liters, tank.t.level);
+    tank.t.level -= got;
+    return got;
+  }
+  function emitFixture(o, fx) {
+    emit({ type: "fixture", object: o.id, fixture: fx.spec.id, on: fx.on, flowing: fx.flowing });
+  }
+  function flowOf(fx) {
+    return fx.spec.flow ?? FLOW_DEFAULTS[fx.spec.kind] ?? 6;
+  }
+  function stepFixture(o, fx, dt) {
+    if (!fx.on) return;
+    if (fx.spec.kind === "flush") {
+      fx.timer -= dt;
+      if (fx.timer <= 0) {
+        fx.on = false;
+        fx.flowing = false;
+        fx.frac = 0;
+        if (fx.spec.part) setPartTarget(o, fx.spec.part, 0);
+        emitFixture(o, fx);
+      }
+      return;
+    }
+    if (dt <= 0) return;
+    const wanted = flowOf(fx) / 60 * dt;
+    const got = drawWater(o, fx, wanted);
+    const flowing = got > 1e-9;
+    fx.frac = wanted > 0 ? Math.min(1, got / wanted) : 0;
+    if (flowing !== fx.flowing) {
+      fx.flowing = flowing;
+      emitFixture(o, fx);
+    }
+  }
+  function toggleFixture(o, id) {
+    const fx = o.fixtures.get(id);
+    if (!fx) return false;
+    if (fx.on) {
+      fx.on = false;
+      fx.flowing = false;
+      fx.frac = 0;
+      if (fx.spec.part) setPartTarget(o, fx.spec.part, 0);
+      emitFixture(o, fx);
+      return true;
+    }
+    fx.on = true;
+    if (fx.spec.part) setPartTarget(o, fx.spec.part, 1);
+    if (fx.spec.kind === "flush") {
+      const volume2 = fx.spec.volume ?? 6;
+      const got = drawWater(o, fx, volume2);
+      fx.flowing = got > 1e-9;
+      fx.frac = fx.flowing ? 1 : 0;
+      fx.timer = FLUSH_SECONDS;
+      if (!fx.flowing) {
+        fx.on = false;
+        if (fx.spec.part) setPartTarget(o, fx.spec.part, 0);
+      }
+    } else {
+      fx.flowing = false;
+      fx.frac = 0;
+      stepFixture(o, fx, 1 / 60);
+    }
+    emitFixture(o, fx);
+    if (!fx.flowing) message("no_water");
+    return true;
+  }
+  function seatTaken(objectId, seatId) {
+    for (const [actor, s] of seats) if (s.object === objectId && s.seat === seatId) return actor;
+    return null;
+  }
+  function stand(actor = DEFAULT_ACTOR) {
+    const s = seats.get(actor);
+    if (!s) return null;
+    seats.delete(actor);
+    const o = objs.get(s.object);
+    const spec = o?.spec.seats?.find((x) => x.id === s.seat);
+    emit({ type: "seat", object: s.object, seat: s.seat, actor, seated: false });
+    if (!o || !spec) return null;
+    return toWorld(o, spec.exit);
+  }
+  function sit(objectId, seatId, actor = DEFAULT_ACTOR) {
+    const o = objs.get(objectId);
+    const seat = o?.spec.seats?.find((s) => s.id === seatId);
+    if (!o || !seat) return null;
+    const holder = seatTaken(objectId, seatId);
+    if (holder && holder !== actor) return null;
+    if (seats.has(actor) && !holder) stand(actor);
+    seats.set(actor, { object: objectId, seat: seatId });
+    const eye = seat.eye ?? (seat.pose === "lie" ? 0.18 : 0.62);
+    emit({ type: "seat", object: objectId, seat: seatId, actor, seated: true });
+    return { eye: toWorld(o, [seat.pos[0], seat.pos[1] + eye, seat.pos[2]]), yaw: o.public.transform.ry + seat.ry + Math.PI, pose: seat.pose };
+  }
+  function push(pos, radius, vel) {
+    for (const o of objs.values()) {
+      if (!o.soft.size) continue;
+      const tr = o.public.transform;
+      const lp = worldToLocal(tr, pos);
+      const lv = rotY(vel, -tr.ry);
+      for (const s of o.soft.values()) {
+        const [w, h, d] = s.spec.size;
+        const hx = w / 2;
+        const hz = Math.max(d, 0.1) / 2;
+        const dx = Math.max(Math.abs(lp[0] - s.spec.anchor[0]) - hx, 0);
+        const dz = Math.max(Math.abs(lp[2] - s.spec.anchor[2]) - hz, 0);
+        if (Math.hypot(dx, dz) > radius) continue;
+        const top = tr.y + s.spec.anchor[1];
+        if (pos[1] + ACTOR_HEIGHT < top - h || pos[1] > top) continue;
+        const cap = 8;
+        s.vax = clamp(s.vax - lv[2] * PUSH_GAIN, -cap, cap);
+        s.vaz = clamp(s.vaz + lv[0] * PUSH_GAIN, -cap, cap);
+        if (s.spec.kind === "panel" && s.spec.part && lv[2] < -0.05 && lp[2] > s.spec.anchor[2]) setPartTarget(o, s.spec.part, 1);
+      }
+    }
+  }
+  function stepSoft(dt) {
+    const sub = Math.max(1, Math.ceil(dt / (1 / 120)));
+    const h = dt / sub;
+    for (const o of objs.values()) {
+      if (!o.soft.size) continue;
+      const wl = rotY([wind[0], 0, wind[1]], -o.public.transform.ry);
+      for (const s of o.soft.values()) {
+        const k = s.spec.stiffness ?? 30;
+        const c = s.spec.damping ?? 4;
+        const max = s.spec.maxAngle ?? 0.7;
+        const gain = s.spec.wind ?? (s.spec.kind === "panel" ? 0 : 1);
+        const gust = gain * (0.6 + 0.4 * Math.sin(time * 1.7 + s.phase)) * 0.1;
+        const fx = -wl[2] * gust;
+        const fz = wl[0] * gust;
+        for (let i = 0; i < sub; i++) {
+          s.vax += (-k * s.ax - c * s.vax + fx) * h;
+          s.vaz += (-k * s.az - c * s.vaz + fz) * h;
+          s.ax += s.vax * h;
+          s.az += s.vaz * h;
+        }
+        if (Math.abs(s.ax) > max) {
+          s.ax = Math.sign(s.ax) * max;
+          s.vax = 0;
+        }
+        if (Math.abs(s.az) > max) {
+          s.az = Math.sign(s.az) * max;
+          s.vaz = 0;
+        }
+      }
+    }
+  }
+  function damage(objectId, target2, amount, _kind) {
+    const o = objs.get(objectId);
+    if (o && options.destruction) {
+      const pos2 = toWorld(o, [0, 0.5, 0]);
+      const type = _kind === "gas" ? "explosive" : _kind === "fabric" ? "slash" : "blunt";
+      const result = options.destruction.hitPart(objectId, target2, { type, point: pos2, energy: Math.max(0, amount), source: "interactables" });
+      const destroyed2 = !!result?.events?.some((e) => e.type === "fracture" && e.part === target2);
+      emit({ type: "damage", object: objectId, target: target2, hp: -1, destroyed: destroyed2 });
+      return { hp: -1, destroyed: destroyed2 };
+    }
+    const st = o?.hp.get(target2);
+    if (!o || !st) return null;
+    if (st.hp <= 0) return { hp: 0, destroyed: true };
+    const before = st.hp;
+    st.hp = Math.max(0, st.hp - Math.max(0, amount));
+    const destroyed = st.hp <= 0;
+    emit({ type: "damage", object: objectId, target: target2, hp: st.hp, destroyed });
+    const pos = toWorld(o, [0, 0.5, 0]);
+    const fuel = o.fuels.get(target2);
+    if (fuel && destroyed && fuel.spec.kind === "gas" && fuel.level > 0) {
+      emit({ type: "explosion", object: objectId, pos, radius: 2 + fuel.level / 5 });
+      fuel.level = 0;
+    }
+    const tank = o.tanks.get(target2);
+    if (tank && before === st.max && st.hp < before) emit({ type: "leak", object: objectId, target: target2, pos });
+    return { hp: st.hp, destroyed };
+  }
+  function deriveInteractions(spec) {
+    const out = [];
+    const used = /* @__PURE__ */ new Set();
+    const partPos = (id, fallback) => spec.parts?.find((p) => p.id === id)?.pivot ?? fallback;
+    const partLabel = (id) => spec.parts?.find((p) => p.id === id)?.label ?? "";
+    const claim = (id) => {
+      if (id) used.add(id);
+    };
+    for (const d of spec.devices ?? []) {
+      claim(d.part);
+      const pos = d.part ? partPos(d.part, [0, 1, 0]) : d.plug ?? [0, 1, 0];
+      if (d.kind === "lamp" && !d.part && !d.plug && d.electric !== false) continue;
+      out.push({ id: `device.${d.id}`, pos, action: { do: "toggle_device", device: d.id }, label: partLabel(d.part) });
+      if (d.kind === "screen" && (d.channels ?? 1) > 1) out.push({ id: `channel.${d.id}`, pos, action: { do: "cycle_device", device: d.id }, label: "" });
+    }
+    for (const s of spec.switches ?? []) {
+      claim(s.part);
+      out.push({ id: `switch.${s.id}`, pos: partPos(s.part, [0, 1.2, 0]), action: { do: "toggle_switch", switch: s.id }, label: partLabel(s.part) });
+    }
+    const driven = new Set((spec.devices ?? []).map((d) => d.fixture));
+    for (const f of spec.fixtures ?? []) {
+      claim(f.part);
+      if (driven.has(f.id)) continue;
+      out.push({ id: `fixture.${f.id}`, pos: f.part ? partPos(f.part, f.outlet) : f.outlet, action: { do: "toggle_fixture", fixture: f.id }, label: partLabel(f.part) });
+    }
+    for (const b of spec.burners ?? []) {
+      claim(b.part);
+      const pos = b.part ? partPos(b.part, b.pos) : b.pos;
+      if (b.needsIgnition) out.push({ id: `ignite.${b.id}`, pos, action: { do: "ignite", burner: b.id }, label: "" });
+      out.push({ id: `burner.${b.id}`, pos, action: { do: "toggle_burner", burner: b.id }, label: partLabel(b.part) });
+    }
+    for (const f of spec.fuels ?? []) {
+      if (!f.valve) continue;
+      claim(f.valve);
+      out.push({ id: `fuel.${f.id}`, pos: partPos(f.valve, [0, 0.5, 0]), action: { do: "toggle_fuel", fuel: f.id }, label: partLabel(f.valve) });
+    }
+    for (const c of spec.containers ?? []) {
+      if (!c.access) out.push({ id: `open.${c.id}`, pos: c.volume.center, action: { do: "open_container", container: c.id }, label: "" });
+    }
+    for (const p of spec.parts ?? []) {
+      if (used.has(p.id)) continue;
+      if (p.label) out.push({ id: `part.${p.id}`, pos: p.pivot, action: { do: "toggle_part", part: p.id }, label: p.label });
+    }
+    for (const c of spec.containers ?? []) {
+      if (c.access && !spec.parts?.find((p) => p.id === c.access)?.label) {
+        out.push({ id: `open.${c.id}`, pos: partPos(c.access, c.volume.center), action: { do: "open_container", container: c.id }, label: "" });
+      }
+    }
+    for (const s of spec.seats ?? []) out.push({ id: `seat.${s.id}`, pos: s.pos, action: { do: "sit", seat: s.id }, label: "" });
+    return out;
+  }
+  function typeName(o) {
+    return table[`type.${o.spec.type}`] ?? humanize(o.spec.type);
+  }
+  function promptOf(o, i) {
+    const a = i.action;
+    let state = null;
+    let def = "";
+    switch (a.do) {
+      case "toggle_part": {
+        const p = o.parts.get(a.part);
+        const open = !!p && targetIsOpen(p);
+        state = open ? "open" : "closed";
+        def = open ? "prompt.close" : "prompt.open";
+        break;
+      }
+      case "open_container": {
+        const c = containerOf(o, a.container);
+        const p = c?.access ? o.parts.get(c.access) : void 0;
+        const open = p ? targetIsOpen(p) : false;
+        state = p ? open ? "open" : "closed" : null;
+        def = open ? "prompt.close" : "prompt.open";
+        break;
+      }
+      case "toggle_device": {
+        const on = !!o.devices.get(a.device)?.on;
+        state = on ? "on" : "off";
+        def = on ? "prompt.turn_off" : "prompt.turn_on";
+        break;
+      }
+      case "toggle_switch": {
+        const sw = o.spec.switches?.find((s) => s.id === a.switch);
+        const on = !!sw && switchIsOn(o, sw);
+        state = on ? "on" : "off";
+        def = on ? "prompt.turn_off" : "prompt.turn_on";
+        break;
+      }
+      case "toggle_breaker": {
+        const on = breaker(a.circuit);
+        state = on ? "on" : "off";
+        def = on ? "prompt.breaker_off" : "prompt.breaker_on";
+        break;
+      }
+      case "toggle_fixture": {
+        const on = !!o.fixtures.get(a.fixture)?.on;
+        state = on ? "on" : "off";
+        def = on ? "prompt.turn_off" : "prompt.turn_on";
+        break;
+      }
+      case "toggle_burner": {
+        const b = o.burners.get(a.burner);
+        const on = !!b && (b.on || b.lit);
+        state = on ? "on" : "off";
+        def = on ? "prompt.turn_off" : "prompt.turn_on";
+        break;
+      }
+      case "toggle_fuel": {
+        const f = o.fuels.get(a.fuel);
+        const open = !!f && valveOpen(o, f);
+        state = open ? "open" : "closed";
+        def = open ? "prompt.close_valve" : "prompt.open_valve";
+        break;
+      }
+      case "take":
+        def = "prompt.take";
+        break;
+      case "read":
+        def = "prompt.read";
+        break;
+      case "ignite":
+        def = "prompt.light";
+        break;
+      case "cycle_device":
+        def = "prompt.change_channel";
+        break;
+      case "sit": {
+        const seat = o.spec.seats?.find((s) => s.id === a.seat);
+        const mine = seats.get(DEFAULT_ACTOR);
+        def = mine && mine.object === o.id && mine.seat === a.seat ? "prompt.get_up" : seat?.pose === "lie" ? "prompt.lie_down" : "prompt.sit";
+        break;
+      }
+    }
+    let key = def;
+    if (i.label) {
+      if (state && table[`${i.label}.${state}`] !== void 0) key = `${i.label}.${state}`;
+      else if (table[i.label] !== void 0) key = i.label;
+    }
+    const vars = { name: typeName(o), circuit: a.do === "toggle_breaker" ? a.name ?? a.circuit : "" };
+    const label = t(key, vars);
+    let verb;
+    let object;
+    if (table[`${key}.verb`] !== void 0) {
+      verb = t(`${key}.verb`, vars);
+      object = table[`${key}.object`] ? t(`${key}.object`, vars) : vars.name;
+    } else {
+      const sp = label.indexOf(" ");
+      verb = sp < 0 ? label : label.slice(0, sp);
+      object = sp < 0 ? vars.name : label.slice(sp + 1);
+    }
+    return { label, verb, object };
+  }
+  function unavailableReason(o, i) {
+    const a = i.action;
+    if (!requirementMet(i)) return "requires_open";
+    switch (a.do) {
+      case "toggle_part": {
+        const p = o.parts.get(a.part);
+        return p && gated(o, p) ? "requires_open" : null;
+      }
+      case "open_container": {
+        const c = containerOf(o, a.container);
+        const p = c?.access ? o.parts.get(c.access) : void 0;
+        return p && gated(o, p) ? "requires_open" : null;
+      }
+      case "toggle_breaker": {
+        const rocker = a.part ? o.parts.get(a.part) : void 0;
+        return rocker && gated(o, rocker) ? "requires_open" : null;
+      }
+      case "take":
+      case "read":
+        return accessible(o.id, a.container) ? null : "requires_open";
+      case "ignite":
+        return o.burners.get(a.burner)?.lit ? "already_lit" : null;
+      case "toggle_burner": {
+        const b = o.burners.get(a.burner);
+        return !b?.spec.needsIgnition || b.lit ? null : "needs_ignition";
+      }
+      case "cycle_device": {
+        const d = o.devices.get(a.device);
+        if (!d || !d.on) return "turn_on_first";
+        return devicePowered(o, d) ? null : "no_power";
+      }
+      default:
+        return null;
+    }
+  }
+  function requirementMet(i) {
+    if (!i.requires) return true;
+    const p = objs.get(i.requires.object)?.parts.get(i.requires.part);
+    return !!p && targetIsOpen(p);
+  }
+  function interactablesOf(o) {
+    return o.interactions.map((i) => {
+      const id = gid(o, i.id);
+      const p = promptOf(o, i);
+      const item = {
+        id,
+        object: o.id,
+        kind: i.action.do,
+        pos: toWorld(o, i.pos),
+        radius: i.radius ?? DEFAULT_RADIUS,
+        label: p.label,
+        verb: p.verb,
+        noun: p.object,
+        available: true,
+        act: (actor) => act(id, actor)
+      };
+      const reason = unavailableReason(o, i) ?? (options.canInteract?.(item, DEFAULT_ACTOR) === false ? "locked" : null);
+      if (reason) {
+        item.available = false;
+        item.reason = reason;
+      }
+      return { item, spec: i, o };
+    });
+  }
+  function interactables() {
+    const out = [];
+    for (const o of objs.values()) for (const e of interactablesOf(o)) out.push(e.item);
+    return out;
+  }
+  function target(eye, opts = {}) {
+    const reach = opts.reach ?? 1.8;
+    const cone = opts.cone ?? 0.45;
+    const dir = [-Math.sin(eye.yaw) * Math.cos(eye.pitch), Math.sin(eye.pitch), -Math.cos(eye.yaw) * Math.cos(eye.pitch)];
+    let best = null;
+    let bestScore = Infinity;
+    for (const o of objs.values()) {
+      for (const e of interactablesOf(o)) {
+        if (!e.item.available && !opts.includeUnavailable) continue;
+        if (opts.kinds && !opts.kinds.includes(e.item.kind)) continue;
+        if (opts.filter && !opts.filter(e.item)) continue;
+        const v = [e.item.pos[0] - eye.x, e.item.pos[1] - eye.y, e.item.pos[2] - eye.z];
+        const d = Math.hypot(v[0], v[1], v[2]);
+        if (d > reach) continue;
+        const cos = d < 1e-6 ? 1 : clamp((v[0] * dir[0] + v[1] * dir[1] + v[2] * dir[2]) / d, -1, 1);
+        const angle = Math.acos(cos);
+        if (angle > cone) continue;
+        const score = angle / cone * 0.6 + d / reach * 0.4;
+        if (score < bestScore) {
+          bestScore = score;
+          best = e.item;
+        }
+      }
+    }
+    return best;
+  }
+  function act(interactableId, actor = DEFAULT_ACTOR) {
+    let found = null;
+    for (const o of objs.values()) {
+      if (!interactableId.startsWith(o.id + ":")) continue;
+      const local = interactableId.slice(o.id.length + 1);
+      if (!o.interactions.some((i) => i.id === local)) continue;
+      found = interactablesOf(o).find((e) => e.spec.id === local) ?? null;
+      if (found) break;
+    }
+    if (!found) return false;
+    if (!requirementMet(found.spec)) return false;
+    if (options.canInteract?.(found.item, actor) === false) return false;
+    return execute(found.o, found.spec.action, actor);
+  }
+  function execute(o, a, actor) {
+    switch (a.do) {
+      case "toggle_part": {
+        const p = o.parts.get(a.part);
+        if (!p || gated(o, p)) return false;
+        setPartTarget(o, a.part, targetIsOpen(p) ? 0 : 1);
+        return true;
+      }
+      case "open_container": {
+        const c = containerOf(o, a.container);
+        if (!c) return false;
+        if (c.access) return execute(o, { do: "toggle_part", part: c.access }, actor);
+        emit({ type: "container", object: o.id, container: c.id, open: true });
+        return true;
+      }
+      case "take": {
+        if (!accessible(o.id, a.container)) return false;
+        const list = o.contents.get(a.container);
+        if (!list) return false;
+        const slot = a.slot ?? list.findIndex((s) => s !== null);
+        if (slot < 0 || !list[slot]) {
+          message("empty");
+          return false;
+        }
+        return take(o.id, a.container, slot, actor) !== null;
+      }
+      case "read": {
+        if (!accessible(o.id, a.container)) return false;
+        const stack = o.contents.get(a.container)?.[a.slot];
+        if (!stack) {
+          message("empty");
+          return false;
+        }
+        const key = typeof stack.data?.text === "string" ? stack.data.text : null;
+        if (!key) return false;
+        message(key);
+        return true;
+      }
+      case "toggle_device": {
+        const d = o.devices.get(a.device);
+        if (!d) return false;
+        setDeviceOn(o, d, !d.on);
+        return true;
+      }
+      case "cycle_device": {
+        const d = o.devices.get(a.device);
+        if (!d || !d.on) return false;
+        if (!devicePowered(o, d)) {
+          message("no_power");
+          return false;
+        }
+        d.channel = (d.channel + 1) % Math.max(1, d.spec.channels ?? 1);
+        emit({ type: "device", object: o.id, device: d.spec.id, on: true, powered: true, channel: d.channel });
+        return true;
+      }
+      case "toggle_switch":
+        return toggleSwitch(o, a.switch);
+      case "toggle_breaker": {
+        const rocker = a.part ? o.parts.get(a.part) : void 0;
+        if (rocker && gated(o, rocker)) return false;
+        const on = !breaker(a.circuit);
+        if (a.part) setPartTarget(o, a.part, on ? 1 : 0);
+        world.power.setBreaker(a.circuit, on);
+        return true;
+      }
+      case "toggle_fixture":
+        return toggleFixture(o, a.fixture);
+      case "toggle_burner":
+        return toggleBurner(o, a.burner);
+      case "ignite":
+        return ignite(o, a.burner);
+      case "toggle_fuel":
+        return toggleFuel(o, a.fuel);
+      case "sit": {
+        const mine = seats.get(actor);
+        if (mine && mine.object === o.id && mine.seat === a.seat) {
+          stand(actor);
+          return true;
+        }
+        return sit(o.id, a.seat, actor) !== null;
+      }
+    }
+  }
+  function emitters() {
+    const out = [];
+    for (const o of objs.values()) {
+      for (const e of o.spec.emitters ?? []) {
+        let intensity = 0;
+        const b = o.burners.get(e.source);
+        const fx = o.fixtures.get(e.source);
+        const dev = o.devices.get(e.source);
+        const fuel = o.fuels.get(e.source);
+        if (b) {
+          const ref = resolveFuel(o, b);
+          const frac = ref ? clamp(ref.f.level / ref.f.spec.capacity, 0, 1) : 0;
+          if (b.lit) intensity = 0.35 + 0.65 * frac;
+          else if (e.kind === "smoke" && b.smoke > 0) intensity = 0.6 * (b.smoke / SMOKE_TAIL);
+        } else if (fx) {
+          if (fx.on && fx.flowing) intensity = fx.frac;
+        } else if (dev) {
+          if (dev.on && devicePowered(o, dev)) intensity = 1;
+        } else if (fuel) {
+          const lit = [...o.burners.values()].some((bb) => bb.lit && resolveFuel(o, bb)?.f === fuel);
+          if (lit) intensity = 0.35 + 0.65 * clamp(fuel.level / fuel.spec.capacity, 0, 1);
+        }
+        if (intensity <= 0) continue;
+        const dir = rotY(e.dir ?? [0, 1, 0], o.public.transform.ry);
+        out.push({ id: gid(o, e.id), object: o.id, kind: e.kind, pos: toWorld(o, e.pos), dir, size: e.size ?? 0.3, ...e.reach !== void 0 ? { reach: e.reach } : {}, intensity: clamp(intensity, 0, 1) });
+      }
+    }
+    return out;
+  }
+  function mirrors(eye, maxDistance = 10, count = 4) {
+    const out = [];
+    for (const o of objs.values()) {
+      for (const m of o.spec.mirrors ?? []) {
+        const center = toWorld(o, applyPart(o, m.part, m.center));
+        const f = partFrame(o, m.part);
+        const ln = f && f.angle !== 0 ? rotateAxis(m.normal, f.axis, f.angle) : m.normal;
+        const normal = rotY(ln, o.public.transform.ry);
+        const len = Math.hypot(normal[0], normal[1], normal[2]) || 1;
+        const n = [normal[0] / len, normal[1] / len, normal[2] / len];
+        const to = [eye[0] - center[0], eye[1] - center[1], eye[2] - center[2]];
+        if (n[0] * to[0] + n[1] * to[1] + n[2] * to[2] <= 0) continue;
+        const distance = Math.hypot(to[0], to[1], to[2]);
+        if (distance > maxDistance) continue;
+        out.push({ id: gid(o, m.id), center, normal: n, w: m.w, h: m.h, distance });
+      }
+    }
+    return out.sort((a, b) => a.distance - b.distance).slice(0, count);
+  }
+  function colliders(opts = {}) {
+    const out = [];
+    const fixed = [];
+    for (const o of objs.values()) {
+      const tr = o.public.transform;
+      for (const c of o.spec.colliders ?? []) {
+        if (c.part && c.offWhenOpen && (o.parts.get(c.part)?.t ?? 0) > 0.5) continue;
+        let extra = 0;
+        if (c.part) {
+          const f = partFrame(o, c.part);
+          if (f && f.angle !== 0 && Math.abs(f.axis[1]) >= 0.5) extra = f.angle * Math.sign(f.axis[1]);
+        }
+        const center = toWorld(o, applyPart(o, c.part, c.center));
+        (c.part ? out : fixed).push({
+          id: gid(o, c.id),
+          object: o.id,
+          cx: center[0],
+          cz: center[2],
+          hw: c.half[0],
+          hd: c.half[2],
+          ry: tr.ry + (c.ry ?? 0) + extra,
+          y0: center[1] - c.half[1],
+          y1: center[1] + c.half[1]
+        });
+      }
+    }
+    if (opts.merge) return [...mergeColliders(fixed, { gap: opts.gap, slack: opts.slack }), ...out];
+    return [...fixed, ...out];
+  }
+  function update(dt) {
+    if (!(dt > 0)) return;
+    time += dt;
+    for (const o of objs.values()) {
+      for (const p of o.parts.values()) {
+        if (p.t === p.target) continue;
+        if (gated(o, p) && p.target > p.t) continue;
+        const step = (p.spec.motion.speed ?? 2.5) * dt;
+        const next = p.t < p.target ? Math.min(p.target, p.t + step) : Math.max(p.target, p.t - step);
+        writeT(o, p, next);
+        if (next === p.target) emit({ type: "part", object: o.id, part: p.spec.id, t: next, target: p.target });
+      }
+    }
+    stepSoft(dt);
+    for (const o of objs.values()) {
+      for (const b of o.burners.values()) {
+        if (b.lit) {
+          const ref = resolveFuel(o, b);
+          if (!ref || !valveOpen(ref.o, ref.f)) {
+            extinguish(o, b, !!b.spec.needsIgnition);
+          } else {
+            ref.f.level = Math.max(0, ref.f.level - b.spec.rate * dt);
+            if (ref.f.level <= 0) extinguish(o, b, !!b.spec.needsIgnition);
+          }
+        } else if (b.on && !b.spec.needsIgnition && canBurn(b, resolveFuel(o, b))) {
+          b.lit = true;
+          b.smoke = 0;
+          emitBurner(o, b);
+        } else if (b.smoke > 0) {
+          b.smoke = Math.max(0, b.smoke - dt);
+        }
+      }
+      if (rain > 0) {
+        for (const tk of o.tanks.values()) {
+          if (tk.spec.rainArea) tk.level = Math.min(tk.spec.capacity, tk.level + rain * tk.spec.rainArea / 3600 * dt);
+        }
+      }
+      for (const tk of o.tanks.values()) {
+        const st = o.hp.get(tk.spec.id);
+        if (st && st.hp < st.max && tk.level > 0) {
+          const rate = 0.5 + 2.5 * (1 - st.hp / st.max);
+          tk.level = Math.max(0, tk.level - rate * dt);
+        }
+      }
+    }
+    for (const o of objs.values()) {
+      for (const d of o.devices.values()) {
+        const fx = d.spec.fixture ? o.fixtures.get(d.spec.fixture) : void 0;
+        if (!fx) continue;
+        const run = d.on && devicePowered(o, d);
+        if (fx.on === run) continue;
+        fx.on = run;
+        if (!run) {
+          fx.flowing = false;
+          fx.frac = 0;
+          emitFixture(o, fx);
+        }
+      }
+      for (const fx of o.fixtures.values()) stepFixture(o, fx, dt);
+    }
+  }
+  function add(id, spec, transform) {
+    if (objs.has(id)) throw new Error(`Object "${id}" already exists`);
+    const pub = { id, spec, transform: { ...transform }, parts: {} };
+    const o = {
+      id,
+      public: pub,
+      spec,
+      parts: /* @__PURE__ */ new Map(),
+      contents: /* @__PURE__ */ new Map(),
+      devices: /* @__PURE__ */ new Map(),
+      fuels: /* @__PURE__ */ new Map(),
+      burners: /* @__PURE__ */ new Map(),
+      tanks: /* @__PURE__ */ new Map(),
+      fixtures: /* @__PURE__ */ new Map(),
+      soft: /* @__PURE__ */ new Map(),
+      hp: /* @__PURE__ */ new Map(),
+      interactions: spec.interactions ?? deriveInteractions(spec)
+    };
+    for (const p of spec.parts ?? []) {
+      const t0 = clamp(p.t0 ?? 0, 0, 1);
+      o.parts.set(p.id, { spec: p, t: t0, target: t0, maxT: 1 });
+      pub.parts[p.id] = t0;
+    }
+    for (const c of spec.containers ?? []) {
+      let list;
+      if (c.contents) list = c.slots.map((_, i) => cloneStack(c.contents?.[i] ?? null));
+      else if (c.loot) list = generateLoot(options.loot, c.loot, c.slots, `${seed}|${id}|${c.id}`, options.items);
+      else list = c.slots.map(() => null);
+      o.contents.set(c.id, list);
+    }
+    for (const d of spec.devices ?? []) {
+      o.devices.set(d.id, { spec: d, on: !!d.on, channel: 0 });
+      if (d.on && d.part) {
+        const p = o.parts.get(d.part);
+        if (p) {
+          p.target = p.maxT;
+          writeT(o, p, p.maxT);
+        }
+      }
+    }
+    for (const f of spec.fuels ?? []) o.fuels.set(f.id, { spec: f, level: clamp(f.level ?? f.capacity, 0, f.capacity) });
+    for (const b of spec.burners ?? []) o.burners.set(b.id, { spec: b, on: false, lit: false, smoke: 0 });
+    for (const tk of spec.tanks ?? []) o.tanks.set(tk.id, { spec: tk, level: clamp(tk.level ?? tk.capacity, 0, tk.capacity) });
+    for (const f of spec.fixtures ?? []) o.fixtures.set(f.id, { spec: f, on: false, flowing: false, frac: 0, timer: 0 });
+    let n = 0;
+    for (const s of spec.soft ?? []) {
+      o.soft.set(s.id, { spec: s, ax: 0, az: 0, vax: 0, vaz: 0, phase: n++ * 2.399963 % (Math.PI * 2) });
+    }
+    for (const d of spec.damage ?? []) o.hp.set(d.target, { max: d.hp, hp: d.hp });
+    objs.set(id, o);
+    if (!defaultTankExplicit && defaultTank === null && o.tanks.size) defaultTank = gid(o, [...o.tanks.keys()][0]);
+    rebuildPlugs();
+    return pub;
+  }
+  function remove(id) {
+    const o = objs.get(id);
+    if (!o) return;
+    for (const [actor, s] of [...seats]) if (s.object === id) seats.delete(actor);
+    objs.delete(id);
+    if (defaultTank && defaultTank.startsWith(id + ":")) defaultTank = null;
+    rebuildPlugs();
+  }
+  function serialize() {
+    const objects = {};
+    for (const o of objs.values()) {
+      objects[o.id] = {
+        parts: Object.fromEntries([...o.parts].map(([k, p]) => [k, p.t])),
+        contents: Object.fromEntries([...o.contents].map(([k, v]) => [k, v.map(cloneStack)])),
+        devices: Object.fromEntries([...o.devices].map(([k, d]) => [k, { on: d.on, channel: d.channel }])),
+        fuels: Object.fromEntries([...o.fuels].map(([k, f]) => [k, { level: f.level, open: valveOpen(o, f) }])),
+        burners: Object.fromEntries([...o.burners].map(([k, b]) => [k, { on: b.on, lit: b.lit }])),
+        tanks: Object.fromEntries([...o.tanks].map(([k, tk]) => [k, tk.level])),
+        fixtures: Object.fromEntries([...o.fixtures].map(([k, f]) => [k, f.on])),
+        hp: Object.fromEntries([...o.hp].map(([k, h]) => [k, h.hp]))
+      };
+    }
+    return {
+      version: 1,
+      objects,
+      grid,
+      breakers: Object.fromEntries(breakers),
+      seats: Object.fromEntries([...seats].map(([a, s]) => [a, { object: s.object, seat: s.seat }])),
+      defaultTank
+    };
+  }
+  function load(state) {
+    for (const [id, st] of Object.entries(state.objects)) {
+      const o = objs.get(id);
+      if (!o) continue;
+      for (const [k, v] of Object.entries(st.parts)) {
+        const p = o.parts.get(k);
+        if (p) {
+          p.target = clamp(v, 0, p.maxT);
+          writeT(o, p, p.target);
+        }
+      }
+      for (const [k, v] of Object.entries(st.contents)) {
+        const c = containerOf(o, k);
+        if (c) o.contents.set(k, c.slots.map((_, i) => cloneStack(v[i] ?? null)));
+      }
+      for (const [k, v] of Object.entries(st.devices)) {
+        const d = o.devices.get(k);
+        if (d) {
+          d.on = v.on;
+          d.channel = v.channel;
+        }
+      }
+      for (const [k, v] of Object.entries(st.fuels)) {
+        const f = o.fuels.get(k);
+        if (f) f.level = v.level;
+      }
+      for (const [k, v] of Object.entries(st.burners)) {
+        const b = o.burners.get(k);
+        if (b) {
+          b.on = v.on;
+          b.lit = v.lit;
+          b.smoke = 0;
+        }
+      }
+      for (const [k, v] of Object.entries(st.tanks)) {
+        const tk = o.tanks.get(k);
+        if (tk) tk.level = v;
+      }
+      for (const [k, v] of Object.entries(st.fixtures)) {
+        const f = o.fixtures.get(k);
+        if (f) {
+          f.on = v;
+          f.flowing = false;
+          f.frac = 0;
+          f.timer = v && f.spec.kind === "flush" ? FLUSH_SECONDS : 0;
+        }
+      }
+      for (const [k, v] of Object.entries(st.hp)) {
+        const h = o.hp.get(k);
+        if (h) h.hp = v;
+      }
+    }
+    grid = state.grid;
+    breakers.clear();
+    for (const [k, v] of Object.entries(state.breakers)) breakers.set(k, v);
+    seats.clear();
+    for (const [a, s] of Object.entries(state.seats)) if (objs.has(s.object)) seats.set(a, { object: s.object, seat: s.seat });
+    defaultTank = state.defaultTank;
+    defaultTankExplicit = true;
+  }
+  const world = {
+    add,
+    remove,
+    get: (id) => objs.get(id)?.public,
+    objects: () => [...objs.values()].map((o) => o.public),
+    update,
+    interactables,
+    target,
+    act,
+    partT: (objectId, partId) => objs.get(objectId)?.parts.get(partId)?.t ?? 0,
+    setDevice,
+    setFixture,
+    setBurner,
+    setPart: (objectId, partId, targetT, instant) => {
+      const o = objs.get(objectId);
+      if (o) setPartTarget(o, partId, targetT, instant);
+    },
+    fitSweep,
+    contents,
+    accessible,
+    take,
+    put,
+    slotPosition,
+    power: {
+      get grid() {
+        return grid;
+      },
+      set grid(on) {
+        world.power.setGrid(on);
+      },
+      setGrid(on) {
+        if (on === grid) return;
+        const before = powerSnapshot();
+        grid = on;
+        emit({ type: "power", grid });
+        emitPowerChanges(before);
+      },
+      setBreaker(circuit, on) {
+        if (breaker(circuit) === on) {
+          breakers.set(circuit, on);
+          return;
+        }
+        const before = powerSnapshot();
+        breakers.set(circuit, on);
+        emitPowerChanges(before);
+      },
+      breaker,
+      isPowered: (objectId, deviceId) => {
+        const r = getDevice(objectId, deviceId);
+        return r ? devicePowered(r.o, r.d) : false;
+      },
+      isOn: (objectId, deviceId) => getDevice(objectId, deviceId)?.d.on ?? false,
+      pluggedInto: (objectId, deviceId) => plugs.get(`${objectId}:${deviceId}`) ?? null,
+      channel: (objectId, deviceId) => getDevice(objectId, deviceId)?.d.channel ?? 0
+    },
+    fuelLevel: (objectId, fuelId) => objs.get(objectId)?.fuels.get(fuelId)?.level ?? 0,
+    isLit: (objectId, burnerId) => objs.get(objectId)?.burners.get(burnerId)?.lit ?? false,
+    water: {
+      setDefaultTank(tankId) {
+        defaultTank = tankId;
+        defaultTankExplicit = true;
+      },
+      level(tankId) {
+        return findGlobal(tankId, (oo, local) => oo.tanks.get(local))?.value.level ?? 0;
+      },
+      refill(tankId, liters) {
+        const f = findGlobal(tankId, (oo, local) => oo.tanks.get(local));
+        if (!f) return 0;
+        const added = Math.max(0, Math.min(liters, f.value.spec.capacity - f.value.level));
+        f.value.level += added;
+        return added;
+      },
+      setRain(mm) {
+        rain = Math.max(0, mm);
+      },
+      isFlowing: (objectId, fixtureId) => {
+        const fx = objs.get(objectId)?.fixtures.get(fixtureId);
+        return !!fx && fx.on && fx.flowing;
+      }
+    },
+    sit,
+    stand,
+    seatOf: (actor = DEFAULT_ACTOR) => {
+      const s = seats.get(actor);
+      return s ? { object: s.object, seat: s.seat } : null;
+    },
+    push,
+    sway: (objectId, softId) => {
+      const s = objs.get(objectId)?.soft.get(softId);
+      return s ? { ax: s.ax, az: s.az } : { ax: 0, az: 0 };
+    },
+    setWind: (x, z) => {
+      wind = [x, z];
+    },
+    emitters,
+    mirrors,
+    colliders,
+    damage,
+    hp: (objectId, target2) => options.destruction ? null : objs.get(objectId)?.hp.get(target2)?.hp ?? null,
+    t,
+    setLocale: (l) => {
+      locale = l;
+      table = resolveStrings(locale, options.strings);
+    },
+    serialize,
+    load
+  };
+  return world;
+}
+export {
+  createWorld,
+  fitsSize,
+  fitsSlot,
+  format,
+  generateLoot,
+  hashString,
+  localToWorld,
+  locales,
+  mergeColliders,
+  pickLocale,
+  poseOf,
+  resolveStrings,
+  rng,
+  rotY,
+  rotateAxis,
+  worldToLocal
+};
+//# sourceMappingURL=index.js.map