@relu-interactives/spatial-ecs 0.5.2 → 0.8.0

package/dist/network/index.cjs

@@ -0,0 +1,4896 @@
+'use strict';
+
+var sdk = require('@colyseus/sdk');
+var THREE5 = require('three');
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var THREE5__namespace = /*#__PURE__*/_interopNamespace(THREE5);
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var view = /* @__PURE__ */ __name((e) => ({
+  id: e.id,
+  owner: e.owner,
+  prefab: e.prefab,
+  x: e.x,
+  y: e.y,
+  z: e.z,
+  qx: e.qx,
+  qy: e.qy,
+  qz: e.qz,
+  qw: e.qw,
+  props: Object.fromEntries(e.props.entries())
+}), "view");
+var _ColyseusTransport = class _ColyseusTransport {
+  constructor(room) {
+    this.room = room;
+  }
+  static async connect(options) {
+    const client = new sdk.Client(options.endpoint);
+    const room = await client.joinOrCreate(options.room, options.join ?? {});
+    return new _ColyseusTransport(room);
+  }
+  get sessionId() {
+    return this.room.sessionId;
+  }
+  get host() {
+    return this.room.state.host;
+  }
+  get players() {
+    return [...this.room.state.players.keys()];
+  }
+  get $() {
+    return sdk.Callbacks.get(this.room);
+  }
+  onEntityAdd(cb) {
+    this.$.onAdd("entities", (entity) => cb(view(entity)));
+  }
+  onEntityChange(cb) {
+    const $ = this.$;
+    $.onAdd("entities", (entity) => {
+      $.onChange(entity, () => cb(view(entity)));
+      $.onChange(entity, "props", () => cb(view(entity)));
+    });
+  }
+  onEntityRemove(cb) {
+    this.$.onRemove("entities", (_entity, id) => cb(id));
+  }
+  onPlayerJoin(cb) {
+    this.$.onAdd("players", (_player, id) => cb(id));
+  }
+  onPlayerLeave(cb) {
+    this.$.onRemove("players", (_player, id) => cb(id));
+  }
+  onMessage(cb) {
+    this.room.onMessage(
+      "m",
+      (m) => cb(m.name, m.payload, m.from)
+    );
+  }
+  onCorrect(cb) {
+    this.room.onMessage("correct", (m) => cb(m.id, m));
+  }
+  onClose(cb) {
+    this.room.onLeave(() => cb());
+  }
+  registerScene(entities) {
+    this.room.send("scene", entities);
+  }
+  spawn(request) {
+    this.room.send("spawn", request);
+  }
+  despawn(id) {
+    this.room.send("despawn", { id });
+  }
+  sendPose(id, pose) {
+    this.room.send("pose", { id, ...pose });
+  }
+  setProp(id, key, json) {
+    this.room.send("prop", { id, key, json });
+  }
+  send(name, payload) {
+    this.room.send("m", { name, payload });
+  }
+  leave() {
+    void this.room.leave();
+  }
+};
+__name(_ColyseusTransport, "ColyseusTransport");
+var ColyseusTransport = _ColyseusTransport;
+
+// core/network/latency.ts
+function withLatency(transport, ms) {
+  if (ms <= 0) return transport;
+  const oneWay = ms / 2;
+  return new Proxy(transport, {
+    get(target, key) {
+      const value = Reflect.get(target, key);
+      if (typeof value !== "function") return value;
+      const name = String(key);
+      const fn = value;
+      if (name === "leave") return fn.bind(target);
+      if (name.startsWith("on")) {
+        return (cb) => fn.call(target, (...args) => {
+          setTimeout(() => cb(...args), oneWay);
+        });
+      }
+      return (...args) => {
+        setTimeout(() => fn.apply(target, args), oneWay);
+      };
+    }
+  });
+}
+__name(withLatency, "withLatency");
+
+// core/Component.ts
+var _Component = class _Component {
+};
+__name(_Component, "Component");
+var Component = _Component;
+
+// core/AnimationStateMachine.ts
+var _AnimationStateMachine = class _AnimationStateMachine {
+  constructor(name, clip, callbacks = {}, loop = false, clipId = null) {
+    this.isPlaying = false;
+    this.isPaused = false;
+    this.name = name;
+    this.clip = clip;
+    this.clipId = clipId;
+    this.loop = loop;
+    this.callbacks = {
+      onStart: callbacks.onStart ?? (() => {
+      }),
+      onPlaying: callbacks.onPlaying ?? (() => {
+      }),
+      onEnd: callbacks.onEnd ?? (() => {
+      })
+    };
+  }
+  setCallbacks(callbacks) {
+    this.callbacks = {
+      onStart: callbacks.onStart ?? this.callbacks.onStart,
+      onPlaying: callbacks.onPlaying ?? this.callbacks.onPlaying,
+      onEnd: callbacks.onEnd ?? this.callbacks.onEnd
+    };
+  }
+  setLoop(loop) {
+    this.loop = loop;
+  }
+  onStart() {
+    this.callbacks.onStart();
+  }
+  onPlaying() {
+    this.callbacks.onPlaying();
+  }
+  onEnd() {
+    this.callbacks.onEnd();
+  }
+  play() {
+    const wasPlaying = this.isPlaying;
+    this.isPlaying = true;
+    this.isPaused = false;
+    if (!wasPlaying) {
+      this.onStart();
+    }
+    this.onPlaying();
+  }
+  pause() {
+    if (!this.isPlaying) {
+      return;
+    }
+    this.isPlaying = false;
+    this.isPaused = true;
+  }
+  stop() {
+    const shouldNotifyEnd = this.isPlaying || this.isPaused;
+    this.isPlaying = false;
+    this.isPaused = false;
+    if (shouldNotifyEnd) {
+      this.onEnd();
+    }
+  }
+};
+__name(_AnimationStateMachine, "AnimationStateMachine");
+var AnimationStateMachine = _AnimationStateMachine;
+var _AnimationStateManager = class _AnimationStateManager {
+  constructor() {
+    this.states = /* @__PURE__ */ new Map();
+    this.activeState = null;
+  }
+  addState(state) {
+    this.states.set(state.name, state);
+    return state;
+  }
+  createState(name, clip, callbacks = {}, loop = false, clipId = null) {
+    const state = new AnimationStateMachine(name, clip, callbacks, loop, clipId);
+    this.states.set(name, state);
+    return state;
+  }
+  removeState(name) {
+    const state = this.states.get(name);
+    if (!state) {
+      return false;
+    }
+    if (this.activeState?.name === name) {
+      this.activeState.stop();
+      this.activeState = null;
+    }
+    return this.states.delete(name);
+  }
+  getState(name) {
+    return this.states.get(name) ?? null;
+  }
+  hasState(name) {
+    return this.states.has(name);
+  }
+  listStates() {
+    return [...this.states.values()];
+  }
+  getActiveState() {
+    return this.activeState;
+  }
+  switchState(name, autoPlay = true) {
+    const next = this.states.get(name) ?? null;
+    if (!next) {
+      return null;
+    }
+    if (this.activeState && this.activeState !== next) {
+      this.activeState.stop();
+    }
+    this.activeState = next;
+    if (autoPlay) {
+      next.play();
+    }
+    return next;
+  }
+  playState(name) {
+    const state = name ? this.switchState(name, false) : this.activeState;
+    if (!state) {
+      return false;
+    }
+    this.activeState = state;
+    state.play();
+    return true;
+  }
+  pauseState(name) {
+    const state = name ? this.states.get(name) : this.activeState;
+    if (!state) {
+      return false;
+    }
+    state.pause();
+    return true;
+  }
+  stopState(name) {
+    const state = name ? this.states.get(name) : this.activeState;
+    if (!state) {
+      return false;
+    }
+    state.stop();
+    if (!name || this.activeState?.name === name) {
+      this.activeState = null;
+    }
+    return true;
+  }
+  clear() {
+    this.stopState();
+    this.states.clear();
+    this.activeState = null;
+  }
+};
+__name(_AnimationStateManager, "AnimationStateManager");
+var AnimationStateManager = _AnimationStateManager;
+
+// core/components/Animation.ts
+var _AnimationComponent = class _AnimationComponent extends Component {
+  constructor(options = {}) {
+    super();
+    this.modelClips = Array.isArray(options.clips) ? [...options.clips] : [];
+    this.importedClips = [];
+    this.clipById = /* @__PURE__ */ new Map();
+    this.clipEntriesById = /* @__PURE__ */ new Map();
+    this.clips = [];
+    this.clipCatalog = [];
+    this.availableClips = [];
+    this.externalClipSources = [];
+    this.setExternalClipSources(options.externalClipSources ?? []);
+    this.refreshClipCatalog();
+    this.paused = options.paused ?? false;
+    this.reverse = options.reverse ?? false;
+    this.timeScale = options.timeScale ?? 1;
+    this.crossFadeDuration = options.crossFadeDuration ?? 0;
+    this.stateManager = new AnimationStateManager();
+    this.states = this.stateManager.listStates();
+    this.active = this.stateManager.getActiveState();
+    this.activeStateName = this.active?.name ?? null;
+    if (Array.isArray(options.states) && options.states.length > 0) {
+      for (const entry of options.states) {
+        this.addState(entry.name, entry.clip, entry.loop ?? false);
+      }
+    }
+    if (typeof options.activeState === "string" && options.activeState.length > 0) {
+      this.switchState(options.activeState, !this.paused);
+    }
+  }
+  refreshClipCatalog() {
+    const catalog = [];
+    const nameCounts = /* @__PURE__ */ new Map();
+    const nextById = /* @__PURE__ */ new Map();
+    const nextEntriesById = /* @__PURE__ */ new Map();
+    for (const [index, clip] of this.modelClips.entries()) {
+      const name = typeof clip?.name === "string" && clip.name.length > 0 ? clip.name : `Clip ${index + 1}`;
+      const id = `model:${index}:${name}`;
+      const count = (nameCounts.get(name) ?? 0) + 1;
+      nameCounts.set(name, count);
+      const entry = {
+        id,
+        name,
+        label: count > 1 ? `${name} (${count})` : name,
+        clip,
+        source: "model",
+        sourceUrl: null
+      };
+      catalog.push(entry);
+      nextById.set(id, clip);
+      nextEntriesById.set(id, entry);
+    }
+    for (const [index, imported] of this.importedClips.entries()) {
+      const clip = imported.clip;
+      const name = typeof clip?.name === "string" && clip.name.length > 0 ? clip.name : `Clip ${index + 1}`;
+      const sourceUrl = imported.sourceUrl;
+      const id = `external:${index}:${name}`;
+      const count = (nameCounts.get(name) ?? 0) + 1;
+      nameCounts.set(name, count);
+      const sourceSuffix = sourceUrl ? sourceUrl.split("/").pop() ?? sourceUrl : "external";
+      const entry = {
+        id,
+        name,
+        label: count > 1 ? `${name} (${count}) \u2022 ${sourceSuffix}` : `${name} \u2022 ${sourceSuffix}`,
+        clip,
+        source: "external",
+        sourceUrl
+      };
+      catalog.push(entry);
+      nextById.set(id, clip);
+      nextEntriesById.set(id, entry);
+    }
+    this.clipById = nextById;
+    this.clipEntriesById = nextEntriesById;
+    this.clipCatalog = catalog;
+    this.clips = catalog.map((entry) => entry.clip);
+    this.availableClips = catalog.map((entry) => entry.name);
+  }
+  refreshStateRefs() {
+    this.states = this.stateManager.listStates();
+    this.active = this.stateManager.getActiveState();
+    this.activeStateName = this.active?.name ?? null;
+  }
+  resolveClipRef(clipRef) {
+    const trimmed = clipRef.trim();
+    if (!trimmed) {
+      return null;
+    }
+    const byId = this.clipById.get(trimmed);
+    if (byId) {
+      return { id: trimmed, clip: byId };
+    }
+    const byName = this.clipCatalog.find((entry) => entry.name === trimmed);
+    if (!byName) {
+      return null;
+    }
+    return { id: byName.id, clip: byName.clip };
+  }
+  setModelClips(clips) {
+    this.modelClips = Array.isArray(clips) ? [...clips] : [];
+    this.refreshClipCatalog();
+  }
+  setImportedClips(clips) {
+    if (!Array.isArray(clips)) {
+      this.importedClips = [];
+      this.refreshClipCatalog();
+      return;
+    }
+    this.importedClips = clips.map((entry) => {
+      if (entry instanceof THREE5__namespace.AnimationClip) {
+        return { clip: entry, sourceUrl: null };
+      }
+      if (!entry || typeof entry !== "object") {
+        return null;
+      }
+      const candidate = entry;
+      if (!(candidate.clip instanceof THREE5__namespace.AnimationClip)) {
+        return null;
+      }
+      return {
+        clip: candidate.clip,
+        sourceUrl: typeof candidate.sourceUrl === "string" && candidate.sourceUrl.length > 0 ? candidate.sourceUrl : null
+      };
+    }).filter((entry) => entry !== null);
+    this.refreshClipCatalog();
+  }
+  setExternalClipSources(sources) {
+    if (!Array.isArray(sources)) {
+      this.externalClipSources = [];
+      return;
+    }
+    const seen = /* @__PURE__ */ new Set();
+    const normalized = [];
+    for (const source of sources) {
+      if (typeof source !== "string") {
+        continue;
+      }
+      const trimmed = source.trim();
+      if (!trimmed || seen.has(trimmed)) {
+        continue;
+      }
+      seen.add(trimmed);
+      normalized.push(trimmed);
+    }
+    this.externalClipSources = normalized;
+  }
+  addState(name, clipRef, loop = false) {
+    if (!name.trim()) {
+      return null;
+    }
+    const resolved = this.resolveClipRef(clipRef);
+    if (!resolved) {
+      return null;
+    }
+    const state = this.stateManager.createState(name, resolved.clip, {}, loop, resolved.id);
+    this.refreshStateRefs();
+    return state;
+  }
+  setStates(states) {
+    const previousActive = this.activeStateName;
+    this.stateManager.clear();
+    for (const state of states) {
+      if (!state.name.trim()) {
+        continue;
+      }
+      let createdState = null;
+      if (typeof state.clipId === "string" && state.clipId.trim().length > 0) {
+        createdState = this.addState(state.name, state.clipId, Boolean(state.loop));
+      }
+      if (!createdState) {
+        this.addState(state.name, state.clip, Boolean(state.loop));
+      }
+    }
+    if (previousActive) {
+      this.stateManager.switchState(previousActive, !this.paused);
+    }
+    this.refreshStateRefs();
+  }
+  getStateConfigs() {
+    return this.states.map((state) => ({
+      name: state.name,
+      clip: state.clip.name,
+      clipId: state.clipId,
+      loop: state.loop
+    }));
+  }
+  setActiveState(name, autoPlay = true) {
+    if (!name) {
+      const stopped = this.stateManager.stopState();
+      this.paused = true;
+      this.refreshStateRefs();
+      return stopped;
+    }
+    return this.switchState(name, autoPlay);
+  }
+  removeState(name) {
+    const removed = this.stateManager.removeState(name);
+    if (removed) {
+      this.refreshStateRefs();
+    }
+    return removed;
+  }
+  switchState(name, autoPlay = true) {
+    const state = this.stateManager.switchState(name, autoPlay);
+    if (!state) {
+      return false;
+    }
+    this.paused = !state.isPlaying;
+    this.refreshStateRefs();
+    return true;
+  }
+  playState(name) {
+    const played = this.stateManager.playState(name);
+    if (!played) {
+      return false;
+    }
+    this.paused = false;
+    this.refreshStateRefs();
+    return true;
+  }
+  pauseState(name) {
+    const paused = this.stateManager.pauseState(name);
+    if (!paused) {
+      return false;
+    }
+    this.paused = true;
+    this.refreshStateRefs();
+    return true;
+  }
+  stopState(name) {
+    const stopped = this.stateManager.stopState(name);
+    if (!stopped) {
+      return false;
+    }
+    this.paused = true;
+    this.refreshStateRefs();
+    return true;
+  }
+};
+__name(_AnimationComponent, "AnimationComponent");
+var AnimationComponent = _AnimationComponent;
+var DEFAULT_FOV = 50;
+var DEFAULT_NEAR = 0.1;
+var DEFAULT_FAR = 2e3;
+var DEFAULT_ORTHO_LEFT = -5;
+var DEFAULT_ORTHO_RIGHT = 5;
+var DEFAULT_ORTHO_TOP = 5;
+var DEFAULT_ORTHO_BOTTOM = -5;
+var DEFAULT_ZOOM = 1;
+function inferProjection(camera) {
+  if (camera instanceof THREE5__namespace.OrthographicCamera) {
+    return "orthographic";
+  }
+  return "perspective";
+}
+__name(inferProjection, "inferProjection");
+function readCameraNear(camera) {
+  if (camera && "near" in camera && typeof camera.near === "number" && Number.isFinite(camera.near)) {
+    return camera.near;
+  }
+  return null;
+}
+__name(readCameraNear, "readCameraNear");
+function readCameraFar(camera) {
+  if (camera && "far" in camera && typeof camera.far === "number" && Number.isFinite(camera.far)) {
+    return camera.far;
+  }
+  return null;
+}
+__name(readCameraFar, "readCameraFar");
+function inferFov(camera) {
+  if (camera instanceof THREE5__namespace.PerspectiveCamera && Number.isFinite(camera.fov)) {
+    return camera.fov;
+  }
+  return DEFAULT_FOV;
+}
+__name(inferFov, "inferFov");
+function inferNear(camera) {
+  const near = readCameraNear(camera);
+  if (near !== null) {
+    return near;
+  }
+  return DEFAULT_NEAR;
+}
+__name(inferNear, "inferNear");
+function inferFar(camera) {
+  const far = readCameraFar(camera);
+  if (far !== null) {
+    return far;
+  }
+  return DEFAULT_FAR;
+}
+__name(inferFar, "inferFar");
+function inferOrthoLeft(camera) {
+  if (camera instanceof THREE5__namespace.OrthographicCamera && Number.isFinite(camera.left)) {
+    return camera.left;
+  }
+  return DEFAULT_ORTHO_LEFT;
+}
+__name(inferOrthoLeft, "inferOrthoLeft");
+function inferOrthoRight(camera) {
+  if (camera instanceof THREE5__namespace.OrthographicCamera && Number.isFinite(camera.right)) {
+    return camera.right;
+  }
+  return DEFAULT_ORTHO_RIGHT;
+}
+__name(inferOrthoRight, "inferOrthoRight");
+function inferOrthoTop(camera) {
+  if (camera instanceof THREE5__namespace.OrthographicCamera && Number.isFinite(camera.top)) {
+    return camera.top;
+  }
+  return DEFAULT_ORTHO_TOP;
+}
+__name(inferOrthoTop, "inferOrthoTop");
+function inferOrthoBottom(camera) {
+  if (camera instanceof THREE5__namespace.OrthographicCamera && Number.isFinite(camera.bottom)) {
+    return camera.bottom;
+  }
+  return DEFAULT_ORTHO_BOTTOM;
+}
+__name(inferOrthoBottom, "inferOrthoBottom");
+function inferZoom(camera) {
+  if (camera && "zoom" in camera && typeof camera.zoom === "number" && Number.isFinite(camera.zoom)) {
+    return camera.zoom;
+  }
+  return DEFAULT_ZOOM;
+}
+__name(inferZoom, "inferZoom");
+var _CameraComponent = class _CameraComponent extends Component {
+  constructor(payload = {}) {
+    super();
+    this.camera = payload.camera ?? new THREE5__namespace.PerspectiveCamera();
+    this.type = payload.type ?? "3d";
+    this.isDefault = typeof payload.isDefault === "boolean" ? payload.isDefault : false;
+    this.projection = payload.projection ?? inferProjection(payload.camera);
+    this.fov = typeof payload.fov === "number" && Number.isFinite(payload.fov) ? payload.fov : inferFov(payload.camera);
+    this.near = typeof payload.near === "number" && Number.isFinite(payload.near) ? payload.near : inferNear(payload.camera);
+    this.far = typeof payload.far === "number" && Number.isFinite(payload.far) ? payload.far : inferFar(payload.camera);
+    this.left = typeof payload.left === "number" && Number.isFinite(payload.left) ? payload.left : inferOrthoLeft(payload.camera);
+    this.right = typeof payload.right === "number" && Number.isFinite(payload.right) ? payload.right : inferOrthoRight(payload.camera);
+    this.top = typeof payload.top === "number" && Number.isFinite(payload.top) ? payload.top : inferOrthoTop(payload.camera);
+    this.bottom = typeof payload.bottom === "number" && Number.isFinite(payload.bottom) ? payload.bottom : inferOrthoBottom(payload.camera);
+    this.zoom = typeof payload.zoom === "number" && Number.isFinite(payload.zoom) ? payload.zoom : inferZoom(payload.camera);
+  }
+};
+__name(_CameraComponent, "CameraComponent");
+var CameraComponent = _CameraComponent;
+
+// core/components/Audio.ts
+var DEFAULT_AUDIO_OPTIONS = {
+  autoplay: false,
+  loop: false,
+  pitch: 1,
+  volume: 1,
+  positional: false,
+  refDistance: 1,
+  distanceModel: "inverse",
+  rolloffFactor: 1,
+  bus: "sfx"
+};
+var _AudioComponent = class _AudioComponent extends Component {
+  constructor(path, options = {}) {
+    super();
+    this.path = path;
+    this.options = {
+      ...DEFAULT_AUDIO_OPTIONS,
+      ...options
+    };
+    this.object = null;
+    this.audio = null;
+    Object.defineProperty(this, "isPlaying", {
+      value: false,
+      writable: true,
+      configurable: true,
+      enumerable: false
+    });
+    Object.defineProperty(this, "isPaused", {
+      value: false,
+      writable: true,
+      configurable: true,
+      enumerable: false
+    });
+  }
+  /**
+   * Signals `AudioSystem` to start (or resume) playback.
+   * Has no direct effect in the editor — `AudioSystem` drives the actual
+   * THREE.js call in preview.
+   */
+  play() {
+    this.isPlaying = true;
+    this.isPaused = false;
+  }
+  /**
+   * Signals `AudioSystem` to pause playback, preserving the current position.
+   * Calling {@link play} afterwards resumes from where it paused.
+   * No-op if not currently playing.
+   */
+  pause() {
+    if (!this.isPlaying) return;
+    this.isPlaying = false;
+    this.isPaused = true;
+  }
+  /**
+   * Signals `AudioSystem` to stop playback and reset the playback position.
+   */
+  stop() {
+    this.isPlaying = false;
+    this.isPaused = false;
+  }
+};
+__name(_AudioComponent, "AudioComponent");
+var AudioComponent = _AudioComponent;
+
+// core/components/Environment.ts
+var DEFAULT_ENVIRONMENT_LIGHTING = {
+  envMapUrl: "",
+  envIntensity: 1,
+  envRotationY: 0,
+  useAsBackground: false,
+  backgroundBlurriness: 0,
+  backgroundIntensity: 1,
+  toneMapping: "none",
+  exposure: 1
+};
+var DEFAULT_ENVIRONMENT_STATE = {
+  skybox: {
+    type: "none",
+    color: "#1e1e1e",
+    imageUrl: "",
+    gradient: {
+      colors: ["#464766", "#657ea6", "#0f0e1a"],
+      effect: "linear"
+    }
+  },
+  fog: {
+    type: "none",
+    color: "#1e1e1e",
+    linear: {
+      near: 1,
+      far: 100
+    },
+    exponential: {
+      density: 2e-3
+    }
+  },
+  gravity: {
+    x: 0,
+    y: -9.81,
+    z: 0
+  },
+  fixedTimeStep: 0.02
+};
+function normalizeColors(colors) {
+  if (!Array.isArray(colors)) {
+    return [...DEFAULT_ENVIRONMENT_STATE.skybox.gradient.colors];
+  }
+  const normalized = colors.filter(
+    (entry) => typeof entry === "string" && entry.length > 0
+  );
+  if (normalized.length === 0) {
+    return [...DEFAULT_ENVIRONMENT_STATE.skybox.gradient.colors];
+  }
+  return normalized;
+}
+__name(normalizeColors, "normalizeColors");
+function normalizeGradientEffect(value) {
+  if (value === "radial" || value === "linear" || value === "angular") {
+    return value;
+  }
+  return DEFAULT_ENVIRONMENT_STATE.skybox.gradient.effect;
+}
+__name(normalizeGradientEffect, "normalizeGradientEffect");
+function normalizeSkyboxType(value) {
+  if (value === "gradient" || value === "color" || value === "none") {
+    return value;
+  }
+  if (value === "image" || value === "Image") {
+    return "image";
+  }
+  return DEFAULT_ENVIRONMENT_STATE.skybox.type;
+}
+__name(normalizeSkyboxType, "normalizeSkyboxType");
+function normalizeFogType(value) {
+  if (value === "linear" || value === "exponential" || value === "none") {
+    return value;
+  }
+  return DEFAULT_ENVIRONMENT_STATE.fog.type;
+}
+__name(normalizeFogType, "normalizeFogType");
+function toFiniteNumber(value, fallback) {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    return fallback;
+  }
+  return value;
+}
+__name(toFiniteNumber, "toFiniteNumber");
+function normalizeImageProjection(value) {
+  return value === "screen" || value === "equirect" ? value : void 0;
+}
+__name(normalizeImageProjection, "normalizeImageProjection");
+function normalizeToneMapping(value) {
+  if (value === "none" || value === "aces" || value === "agx" || value === "neutral") {
+    return value;
+  }
+  return DEFAULT_ENVIRONMENT_LIGHTING.toneMapping;
+}
+__name(normalizeToneMapping, "normalizeToneMapping");
+function normalizeEnvironmentLighting(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return void 0;
+  }
+  const lighting = value;
+  const defaults = DEFAULT_ENVIRONMENT_LIGHTING;
+  return {
+    envMapUrl: typeof lighting.envMapUrl === "string" ? lighting.envMapUrl : defaults.envMapUrl,
+    envIntensity: Math.max(0, toFiniteNumber(lighting.envIntensity, defaults.envIntensity)),
+    envRotationY: toFiniteNumber(lighting.envRotationY, defaults.envRotationY),
+    useAsBackground: typeof lighting.useAsBackground === "boolean" ? lighting.useAsBackground : defaults.useAsBackground,
+    backgroundBlurriness: Math.min(
+      1,
+      Math.max(0, toFiniteNumber(lighting.backgroundBlurriness, defaults.backgroundBlurriness))
+    ),
+    backgroundIntensity: Math.max(
+      0,
+      toFiniteNumber(lighting.backgroundIntensity, defaults.backgroundIntensity)
+    ),
+    toneMapping: normalizeToneMapping(lighting.toneMapping),
+    exposure: Math.max(0, toFiniteNumber(lighting.exposure, defaults.exposure))
+  };
+}
+__name(normalizeEnvironmentLighting, "normalizeEnvironmentLighting");
+var _Environment = class _Environment extends Component {
+  constructor(values) {
+    super();
+    const skybox = values?.skybox;
+    const fog = values?.fog;
+    const gravity = values?.gravity;
+    const skyboxState = {
+      type: normalizeSkyboxType(skybox?.type),
+      color: typeof skybox?.color === "string" ? skybox.color : DEFAULT_ENVIRONMENT_STATE.skybox.color,
+      imageUrl: typeof skybox?.imageUrl === "string" ? skybox.imageUrl : DEFAULT_ENVIRONMENT_STATE.skybox.imageUrl,
+      gradient: {
+        colors: normalizeColors(skybox?.gradient?.colors),
+        effect: normalizeGradientEffect(skybox?.gradient?.effect)
+      }
+    };
+    const imageProjection = normalizeImageProjection(skybox?.imageProjection);
+    if (imageProjection) {
+      skyboxState.imageProjection = imageProjection;
+    }
+    this.values = {
+      skybox: skyboxState,
+      fog: {
+        type: normalizeFogType(fog?.type),
+        color: typeof fog?.color === "string" ? fog.color : DEFAULT_ENVIRONMENT_STATE.fog.color,
+        linear: {
+          near: toFiniteNumber(
+            fog?.linear?.near,
+            DEFAULT_ENVIRONMENT_STATE.fog.linear.near
+          ),
+          far: toFiniteNumber(
+            fog?.linear?.far,
+            DEFAULT_ENVIRONMENT_STATE.fog.linear.far
+          )
+        },
+        exponential: {
+          density: toFiniteNumber(
+            fog?.exponential?.density,
+            DEFAULT_ENVIRONMENT_STATE.fog.exponential.density
+          )
+        }
+      },
+      gravity: {
+        x: toFiniteNumber(gravity?.x, DEFAULT_ENVIRONMENT_STATE.gravity.x),
+        y: toFiniteNumber(gravity?.y, DEFAULT_ENVIRONMENT_STATE.gravity.y),
+        z: toFiniteNumber(gravity?.z, DEFAULT_ENVIRONMENT_STATE.gravity.z)
+      },
+      fixedTimeStep: toFiniteNumber(
+        values?.fixedTimeStep,
+        DEFAULT_ENVIRONMENT_STATE.fixedTimeStep
+      )
+    };
+    const lighting = normalizeEnvironmentLighting(values?.lighting);
+    if (lighting) {
+      this.values.lighting = lighting;
+    }
+  }
+};
+__name(_Environment, "Environment");
+var Environment = _Environment;
+
+// core/components/Postprocessing.ts
+var DEFAULT_POSTPROCESSING_STATE = {
+  postEnabled: false,
+  dof: {
+    enabled: false,
+    focusDistance: 0.015,
+    focalLength: 0.018,
+    bokehScale: 3
+  },
+  bloom: {
+    enabled: false,
+    intensity: 1.2,
+    threshold: 0.2,
+    radius: 0.7
+  },
+  vignette: {
+    enabled: false,
+    offset: 0.05,
+    darkness: 1.2
+  },
+  chromAberration: {
+    enabled: false,
+    offsetX: 3e-3,
+    offsetY: 3e-3
+  },
+  noise: {
+    enabled: false,
+    opacity: 0.12
+  },
+  pixelation: {
+    enabled: false,
+    granularity: 6
+  },
+  toneMapping: {
+    enabled: false,
+    exposure: 1.3
+  },
+  hueSaturation: {
+    enabled: false,
+    hue: 0.05,
+    saturation: 0.2
+  },
+  sepia: {
+    enabled: false,
+    intensity: 0.5
+  },
+  smaa: {
+    enabled: false
+  },
+  ssao: {
+    enabled: false,
+    intensity: 1.5,
+    radius: 0.25
+  },
+  dotScreen: {
+    enabled: false,
+    dotScreenScale: 1.2,
+    dotScreenAngle: 1.57,
+    blendFunction: void 0,
+    opacity: void 0
+  },
+  glitch: {
+    enabled: false,
+    blendFunction: void 0,
+    delay: void 0,
+    duration: void 0,
+    dtSize: void 0,
+    columns: void 0,
+    ratio: void 0,
+    mode: void 0}
+};
+function asRecord(value) {
+  if (!value || typeof value !== "object") {
+    return null;
+  }
+  return value;
+}
+__name(asRecord, "asRecord");
+function toFiniteNumber2(value, fallback) {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    return fallback;
+  }
+  return value;
+}
+__name(toFiniteNumber2, "toFiniteNumber");
+function toBoolean(value, fallback) {
+  if (typeof value !== "boolean") {
+    return fallback;
+  }
+  return value;
+}
+__name(toBoolean, "toBoolean");
+function normalizeNumberTuple(value) {
+  if (!Array.isArray(value) || value.length !== 2) {
+    return void 0;
+  }
+  if (typeof value[0] !== "number" || !Number.isFinite(value[0]) || typeof value[1] !== "number" || !Number.isFinite(value[1])) {
+    return void 0;
+  }
+  return [value[0], value[1]];
+}
+__name(normalizeNumberTuple, "normalizeNumberTuple");
+function normalizePostprocessing(value) {
+  const postprocessing = asRecord(value);
+  const defaults = DEFAULT_POSTPROCESSING_STATE;
+  const dof = asRecord(postprocessing?.dof);
+  const bloom = asRecord(postprocessing?.bloom);
+  const vignette = asRecord(postprocessing?.vignette);
+  const chromAberration = asRecord(postprocessing?.chromAberration);
+  const noise = asRecord(postprocessing?.noise);
+  const pixelation = asRecord(postprocessing?.pixelation);
+  const toneMapping = asRecord(postprocessing?.toneMapping);
+  const hueSaturation = asRecord(postprocessing?.hueSaturation);
+  const sepia = asRecord(postprocessing?.sepia);
+  const smaa = asRecord(postprocessing?.smaa);
+  const ssao = asRecord(postprocessing?.ssao);
+  const dotScreen = asRecord(postprocessing?.dotScreen);
+  const glitch = asRecord(postprocessing?.glitch);
+  const glitchChromaticAberrationOffset = asRecord(
+    glitch?.chromaticAberrationOffset
+  );
+  const glitchStrength = asRecord(glitch?.strength);
+  const dotScreenScale = toFiniteNumber2(
+    dotScreen?.dotScreenScale,
+    defaults.dotScreen.dotScreenScale
+  );
+  const dotScreenAngle = toFiniteNumber2(
+    dotScreen?.dotScreenAngle,
+    defaults.dotScreen.dotScreenAngle
+  );
+  const normalizedGlitchStrength = typeof glitch?.strength === "number" && Number.isFinite(glitch.strength) ? glitch.strength : glitchStrength && typeof glitchStrength.x === "number" && Number.isFinite(glitchStrength.x) && typeof glitchStrength.y === "number" && Number.isFinite(glitchStrength.y) ? { x: glitchStrength.x, y: glitchStrength.y } : void 0;
+  const normalizedGlitchChromaticAberrationOffset = normalizeNumberTuple(glitch?.chromaticAberrationOffset) ?? (glitchChromaticAberrationOffset && typeof glitchChromaticAberrationOffset.x === "number" && Number.isFinite(glitchChromaticAberrationOffset.x) && typeof glitchChromaticAberrationOffset.y === "number" && Number.isFinite(glitchChromaticAberrationOffset.y) ? {
+    x: glitchChromaticAberrationOffset.x,
+    y: glitchChromaticAberrationOffset.y
+  } : void 0);
+  return {
+    postEnabled: toBoolean(postprocessing?.postEnabled, defaults.postEnabled),
+    dof: {
+      enabled: toBoolean(dof?.enabled, defaults.dof.enabled),
+      focusDistance: toFiniteNumber2(dof?.focusDistance, defaults.dof.focusDistance),
+      focalLength: toFiniteNumber2(dof?.focalLength, defaults.dof.focalLength),
+      bokehScale: toFiniteNumber2(dof?.bokehScale, defaults.dof.bokehScale)
+    },
+    bloom: {
+      enabled: toBoolean(bloom?.enabled, defaults.bloom.enabled),
+      intensity: toFiniteNumber2(bloom?.intensity, defaults.bloom.intensity),
+      threshold: toFiniteNumber2(bloom?.threshold, defaults.bloom.threshold),
+      radius: toFiniteNumber2(bloom?.radius, defaults.bloom.radius)
+    },
+    vignette: {
+      enabled: toBoolean(vignette?.enabled, defaults.vignette.enabled),
+      offset: toFiniteNumber2(vignette?.offset, defaults.vignette.offset),
+      darkness: toFiniteNumber2(vignette?.darkness, defaults.vignette.darkness)
+    },
+    chromAberration: {
+      enabled: toBoolean(chromAberration?.enabled, defaults.chromAberration.enabled),
+      offsetX: toFiniteNumber2(chromAberration?.offsetX, defaults.chromAberration.offsetX),
+      offsetY: toFiniteNumber2(chromAberration?.offsetY, defaults.chromAberration.offsetY)
+    },
+    noise: {
+      enabled: toBoolean(noise?.enabled, defaults.noise.enabled),
+      opacity: toFiniteNumber2(noise?.opacity, defaults.noise.opacity)
+    },
+    pixelation: {
+      enabled: toBoolean(pixelation?.enabled, defaults.pixelation.enabled),
+      granularity: toFiniteNumber2(pixelation?.granularity, defaults.pixelation.granularity)
+    },
+    toneMapping: {
+      enabled: toBoolean(toneMapping?.enabled, defaults.toneMapping.enabled),
+      exposure: toFiniteNumber2(toneMapping?.exposure, defaults.toneMapping.exposure)
+    },
+    hueSaturation: {
+      enabled: toBoolean(hueSaturation?.enabled, defaults.hueSaturation.enabled),
+      hue: toFiniteNumber2(hueSaturation?.hue, defaults.hueSaturation.hue),
+      saturation: toFiniteNumber2(
+        hueSaturation?.saturation,
+        defaults.hueSaturation.saturation
+      )
+    },
+    sepia: {
+      enabled: toBoolean(sepia?.enabled, defaults.sepia.enabled),
+      intensity: toFiniteNumber2(sepia?.intensity, defaults.sepia.intensity)
+    },
+    smaa: {
+      enabled: toBoolean(smaa?.enabled, defaults.smaa.enabled)
+    },
+    ssao: {
+      enabled: toBoolean(ssao?.enabled, defaults.ssao.enabled),
+      intensity: toFiniteNumber2(ssao?.intensity, defaults.ssao.intensity),
+      radius: toFiniteNumber2(ssao?.radius, defaults.ssao.radius)
+    },
+    dotScreen: {
+      enabled: toBoolean(dotScreen?.enabled, defaults.dotScreen.enabled),
+      dotScreenScale,
+      dotScreenAngle,
+      scale: toFiniteNumber2(dotScreen?.scale, dotScreenScale),
+      angle: toFiniteNumber2(dotScreen?.angle, dotScreenAngle),
+      blendFunction: typeof dotScreen?.blendFunction === "number" && Number.isFinite(dotScreen.blendFunction) ? dotScreen.blendFunction : defaults.dotScreen.blendFunction,
+      opacity: typeof dotScreen?.opacity === "number" && Number.isFinite(dotScreen.opacity) ? dotScreen.opacity : defaults.dotScreen.opacity
+    },
+    glitch: {
+      enabled: toBoolean(glitch?.enabled, defaults.glitch.enabled),
+      blendFunction: typeof glitch?.blendFunction === "number" && Number.isFinite(glitch.blendFunction) ? glitch.blendFunction : defaults.glitch.blendFunction,
+      chromaticAberrationOffset: normalizedGlitchChromaticAberrationOffset,
+      delay: normalizeNumberTuple(glitch?.delay) ?? defaults.glitch.delay,
+      duration: normalizeNumberTuple(glitch?.duration) ?? defaults.glitch.duration,
+      strength: normalizedGlitchStrength,
+      dtSize: typeof glitch?.dtSize === "number" && Number.isFinite(glitch.dtSize) ? glitch.dtSize : defaults.glitch.dtSize,
+      columns: typeof glitch?.columns === "number" && Number.isFinite(glitch.columns) ? glitch.columns : defaults.glitch.columns,
+      ratio: typeof glitch?.ratio === "number" && Number.isFinite(glitch.ratio) ? glitch.ratio : defaults.glitch.ratio,
+      mode: typeof glitch?.mode === "string" ? glitch.mode : defaults.glitch.mode,
+      active: toBoolean(glitch?.active, false)
+    }
+  };
+}
+__name(normalizePostprocessing, "normalizePostprocessing");
+var _Postprocessing = class _Postprocessing extends Component {
+  constructor(values) {
+    super();
+    this.values = normalizePostprocessing(values);
+  }
+};
+__name(_Postprocessing, "Postprocessing");
+var Postprocessing = _Postprocessing;
+var DEFAULT_MESH_GEOMETRY_PARAMETERS = {
+  capsule: { radius: 0.5, height: 1 },
+  cube: { width: 1, height: 1, depth: 1 },
+  cylinder: { radius: 0.5, height: 1 },
+  plane: { width: 100, height: 100 },
+  sphere: { radius: 0.5 }
+};
+var GEOMETRY_TYPE_BY_KIND = {
+  capsule: "CapsuleGeometry",
+  cube: "BoxGeometry",
+  cylinder: "CylinderGeometry",
+  model: "Model",
+  plane: "PlaneGeometry",
+  sphere: "SphereGeometry"
+};
+var _MeshGeometryComponent = class _MeshGeometryComponent extends Component {
+  constructor(kind, object, parameters, options) {
+    super();
+    this.kind = kind;
+    this.geometryType = GEOMETRY_TYPE_BY_KIND[kind];
+    this.object = object;
+    this.modelName = options?.modelName ?? "";
+    this.castShadow = options?.castShadow ?? false;
+    this.receiveShadow = options?.receiveShadow ?? false;
+    switch (kind) {
+      case "cube":
+        this.parameters = {
+          ...DEFAULT_MESH_GEOMETRY_PARAMETERS.cube,
+          ...parameters
+        };
+        break;
+      case "plane":
+        this.parameters = {
+          ...DEFAULT_MESH_GEOMETRY_PARAMETERS.plane,
+          ...parameters
+        };
+        break;
+      case "sphere":
+        this.parameters = {
+          ...DEFAULT_MESH_GEOMETRY_PARAMETERS.sphere,
+          ...parameters
+        };
+        break;
+      case "cylinder":
+        this.parameters = {
+          ...DEFAULT_MESH_GEOMETRY_PARAMETERS.cylinder,
+          ...parameters
+        };
+        break;
+      case "capsule":
+        this.parameters = {
+          ...DEFAULT_MESH_GEOMETRY_PARAMETERS.capsule,
+          ...parameters
+        };
+        break;
+      case "model":
+        this.parameters = {};
+        break;
+    }
+  }
+};
+__name(_MeshGeometryComponent, "MeshGeometryComponent");
+var MeshGeometryComponent = _MeshGeometryComponent;
+
+// core/components/InstancedMesh.ts
+var DEFAULT_INSTANCED_MESH_PARAMETERS = {
+  capsule: DEFAULT_MESH_GEOMETRY_PARAMETERS.capsule,
+  cube: DEFAULT_MESH_GEOMETRY_PARAMETERS.cube,
+  cylinder: DEFAULT_MESH_GEOMETRY_PARAMETERS.cylinder,
+  model: DEFAULT_MESH_GEOMETRY_PARAMETERS.cube,
+  plane: DEFAULT_MESH_GEOMETRY_PARAMETERS.plane,
+  sphere: DEFAULT_MESH_GEOMETRY_PARAMETERS.sphere
+};
+var _InstancedMeshComponent = class _InstancedMeshComponent extends Component {
+  constructor(meshKind = "cube", meshParameters, options) {
+    super();
+    this.meshKind = meshKind;
+    this.modelPath = options?.modelPath ?? "";
+    this.meshParameters = {
+      ...DEFAULT_INSTANCED_MESH_PARAMETERS[meshKind],
+      ...meshParameters ?? {}
+    };
+    this.castShadow = options?.castShadow ?? false;
+    this.receiveShadow = options?.receiveShadow ?? false;
+    this.instanceEntityIds = options?.instanceEntityIds ?? [];
+    this.instancedMesh = null;
+  }
+  /** Sanitize and return a copy of the current mesh parameters with valid values. */
+  getSanitizedParameters() {
+    const MIN_DIM = 0.01;
+    const MIN_RAD = 1e-3;
+    const sanitize = /* @__PURE__ */ __name((v, min) => Number.isFinite(v) ? Math.max(min, v) : min, "sanitize");
+    switch (this.meshKind) {
+      case "cube": {
+        const p = this.meshParameters;
+        return {
+          width: sanitize(p.width, MIN_DIM),
+          height: sanitize(p.height, MIN_DIM),
+          depth: sanitize(p.depth, MIN_DIM)
+        };
+      }
+      case "plane": {
+        const p = this.meshParameters;
+        return {
+          width: sanitize(p.width, MIN_DIM),
+          height: sanitize(p.height, MIN_DIM)
+        };
+      }
+      case "sphere": {
+        const p = this.meshParameters;
+        return { radius: sanitize(p.radius, MIN_RAD) };
+      }
+      case "cylinder":
+      case "capsule": {
+        const p = this.meshParameters;
+        return {
+          radius: sanitize(p.radius, MIN_RAD),
+          height: sanitize(p.height, MIN_DIM)
+        };
+      }
+      case "model":
+        return DEFAULT_MESH_GEOMETRY_PARAMETERS.cube;
+    }
+  }
+};
+__name(_InstancedMeshComponent, "InstancedMeshComponent");
+var InstancedMeshComponent = _InstancedMeshComponent;
+
+// core/components/InstanceSlotComponent.ts
+var _InstanceSlotComponent = class _InstanceSlotComponent extends Component {
+  constructor(groupEntityId, slotIndex) {
+    super();
+    this.groupEntityId = groupEntityId;
+    this.slotIndex = slotIndex;
+  }
+};
+__name(_InstanceSlotComponent, "InstanceSlotComponent");
+var InstanceSlotComponent = _InstanceSlotComponent;
+
+// core/components/Physics.ts
+var DEFAULT_RIGIDBODY_STATE = {
+  enabled: true,
+  type: "dynamic",
+  mass: 1,
+  linearDamping: 0,
+  angularDamping: 0,
+  gravityScale: 1,
+  canSleep: true,
+  ccdEnabled: false,
+  lockTranslations: false,
+  lockRotations: false};
+var DEFAULT_COLLIDER_STATE = {
+  enabled: true,
+  shape: "cuboid",
+  offsetPosition: {
+    x: 0,
+    y: 0,
+    z: 0
+  },
+  offsetRotation: {
+    x: 0,
+    y: 0,
+    z: 0
+  },
+  size: {
+    x: 1,
+    y: 1,
+    z: 1
+  },
+  radius: 0.5,
+  height: 1,
+  restitution: 0,
+  friction: 0.5,
+  isSensor: false
+};
+function asRecord2(value) {
+  if (!value || typeof value !== "object") {
+    return null;
+  }
+  return value;
+}
+__name(asRecord2, "asRecord");
+function toFiniteNumber3(value, fallback) {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    return fallback;
+  }
+  return value;
+}
+__name(toFiniteNumber3, "toFiniteNumber");
+function toBoolean2(value, fallback) {
+  if (typeof value !== "boolean") {
+    return fallback;
+  }
+  return value;
+}
+__name(toBoolean2, "toBoolean");
+function toRigidbodyType(value, fallback) {
+  if (value === "dynamic" || value === "fixed" || value === "kinematicPosition" || value === "kinematicVelocity") {
+    return value;
+  }
+  return fallback;
+}
+__name(toRigidbodyType, "toRigidbodyType");
+function toColliderShape(value, fallback) {
+  if (value === "cuboid" || value === "ball" || value === "capsule" || value === "cylinder" || value === "trimesh") {
+    return value;
+  }
+  return fallback;
+}
+__name(toColliderShape, "toColliderShape");
+function normalizeRigidbodyState(value) {
+  const source = asRecord2(value);
+  const defaults = DEFAULT_RIGIDBODY_STATE;
+  const legacyLockTranslations = toBoolean2(
+    source?.lockTranslations,
+    defaults.lockTranslations
+  );
+  const legacyLockRotations = toBoolean2(
+    source?.lockRotations,
+    defaults.lockRotations
+  );
+  const lockTranslationX = toBoolean2(
+    source?.lockTranslationX,
+    legacyLockTranslations
+  );
+  const lockTranslationY = toBoolean2(
+    source?.lockTranslationY,
+    legacyLockTranslations
+  );
+  const lockTranslationZ = toBoolean2(
+    source?.lockTranslationZ,
+    legacyLockTranslations
+  );
+  const lockRotationX = toBoolean2(source?.lockRotationX, legacyLockRotations);
+  const lockRotationY = toBoolean2(source?.lockRotationY, legacyLockRotations);
+  const lockRotationZ = toBoolean2(source?.lockRotationZ, legacyLockRotations);
+  return {
+    enabled: toBoolean2(source?.enabled, defaults.enabled),
+    type: toRigidbodyType(source?.type, defaults.type),
+    mass: Math.max(1e-4, toFiniteNumber3(source?.mass, defaults.mass)),
+    linearDamping: Math.max(
+      0,
+      toFiniteNumber3(source?.linearDamping, defaults.linearDamping)
+    ),
+    angularDamping: Math.max(
+      0,
+      toFiniteNumber3(source?.angularDamping, defaults.angularDamping)
+    ),
+    gravityScale: toFiniteNumber3(source?.gravityScale, defaults.gravityScale),
+    canSleep: toBoolean2(source?.canSleep, defaults.canSleep),
+    ccdEnabled: toBoolean2(source?.ccdEnabled, defaults.ccdEnabled),
+    lockTranslations: legacyLockTranslations,
+    lockTranslationX,
+    lockTranslationY,
+    lockTranslationZ,
+    lockRotations: legacyLockRotations,
+    lockRotationX,
+    lockRotationY,
+    lockRotationZ
+  };
+}
+__name(normalizeRigidbodyState, "normalizeRigidbodyState");
+function normalizeColliderState(value) {
+  const source = asRecord2(value);
+  const defaults = DEFAULT_COLLIDER_STATE;
+  const offsetPosition = asRecord2(source?.offsetPosition);
+  const offsetRotation = asRecord2(source?.offsetRotation);
+  const size = asRecord2(source?.size);
+  return {
+    enabled: toBoolean2(source?.enabled, defaults.enabled),
+    shape: toColliderShape(source?.shape, defaults.shape),
+    offsetPosition: {
+      x: toFiniteNumber3(offsetPosition?.x, defaults.offsetPosition.x),
+      y: toFiniteNumber3(offsetPosition?.y, defaults.offsetPosition.y),
+      z: toFiniteNumber3(offsetPosition?.z, defaults.offsetPosition.z)
+    },
+    offsetRotation: {
+      x: toFiniteNumber3(offsetRotation?.x, defaults.offsetRotation.x),
+      y: toFiniteNumber3(offsetRotation?.y, defaults.offsetRotation.y),
+      z: toFiniteNumber3(offsetRotation?.z, defaults.offsetRotation.z)
+    },
+    size: {
+      x: Math.max(1e-4, toFiniteNumber3(size?.x, defaults.size.x)),
+      y: Math.max(1e-4, toFiniteNumber3(size?.y, defaults.size.y)),
+      z: Math.max(1e-4, toFiniteNumber3(size?.z, defaults.size.z))
+    },
+    radius: Math.max(1e-4, toFiniteNumber3(source?.radius, defaults.radius)),
+    height: Math.max(1e-4, toFiniteNumber3(source?.height, defaults.height)),
+    restitution: Math.max(0, toFiniteNumber3(source?.restitution, defaults.restitution)),
+    friction: Math.max(0, toFiniteNumber3(source?.friction, defaults.friction)),
+    isSensor: toBoolean2(source?.isSensor, defaults.isSensor)
+  };
+}
+__name(normalizeColliderState, "normalizeColliderState");
+function normalizePhysicsState(value) {
+  const source = asRecord2(value);
+  return {
+    rigidbody: normalizeRigidbodyState(
+      source?.rigidbody ?? void 0
+    ),
+    collider: normalizeColliderState(
+      source?.collider ?? void 0
+    )
+  };
+}
+__name(normalizePhysicsState, "normalizePhysicsState");
+function setPhysicsLiveRef(component, key, value) {
+  Object.defineProperty(component, key, {
+    value,
+    writable: true,
+    configurable: true,
+    enumerable: false
+  });
+}
+__name(setPhysicsLiveRef, "setPhysicsLiveRef");
+var _PhysicsComponent = class _PhysicsComponent extends Component {
+  constructor(values) {
+    super();
+    this.values = normalizePhysicsState(values);
+    setPhysicsLiveRef(this, "rigidBody", null);
+    setPhysicsLiveRef(this, "collider", null);
+  }
+  /**
+   * Patch rigidbody and/or collider state. Each sub-object is deep-merged
+   * with the current values via the respective normalizer.
+   */
+  setValues(patch) {
+    this.values = normalizePhysicsState({
+      rigidbody: { ...this.values.rigidbody, ...patch.rigidbody ?? {} },
+      collider: { ...this.values.collider, ...patch.collider ?? {} }
+    });
+  }
+};
+__name(_PhysicsComponent, "PhysicsComponent");
+var PhysicsComponent = _PhysicsComponent;
+
+// core/components/Image.ts
+var _ImageComponent = class _ImageComponent extends Component {
+  constructor(path, width = 1, height = 1) {
+    super();
+    this.path = path;
+    this.width = width;
+    this.height = height;
+    this.texture = null;
+    this.object = null;
+  }
+};
+__name(_ImageComponent, "ImageComponent");
+var ImageComponent = _ImageComponent;
+
+// core/components/ImageTarget.ts
+var _ImageTarget = class _ImageTarget extends Component {
+  constructor(options, texture, object) {
+    super();
+    this.targets = options?.targets ?? [];
+    this.compiledTargetUrl = options?.compiledTargetUrl;
+    this.compiledTargetDir = options?.compiledTargetDir;
+    this.texture = texture ?? null;
+    this.object = object ?? null;
+  }
+};
+__name(_ImageTarget, "ImageTarget");
+var ImageTarget = _ImageTarget;
+function toHexColor(value) {
+  return `#${value.getHexString()}`;
+}
+__name(toHexColor, "toHexColor");
+function createValueState(light) {
+  const base = {
+    color: toHexColor(light.color),
+    intensity: light.intensity,
+    castShadow: light.castShadow ?? false,
+    frustumCulling: light.frustumCulled
+  };
+  if (light instanceof THREE5__namespace.PointLight) {
+    base.distance = light.distance;
+    base.decay = light.decay;
+  } else if (light instanceof THREE5__namespace.SpotLight) {
+    base.distance = light.distance;
+    base.decay = light.decay;
+    base.angle = light.angle;
+    base.penumbra = light.penumbra;
+  } else if (light instanceof THREE5__namespace.RectAreaLight) {
+    base.width = light.width;
+    base.height = light.height;
+  }
+  return base;
+}
+__name(createValueState, "createValueState");
+var _LightComponent = class _LightComponent extends Component {
+  constructor(light) {
+    super();
+    this.light = light;
+    this.type = light.type;
+    this.values = createValueState(light);
+  }
+  setValues(patch) {
+    this.values = {
+      ...this.values,
+      ...patch
+    };
+  }
+};
+__name(_LightComponent, "LightComponent");
+var LightComponent = _LightComponent;
+function toHexColor2(value, fallback) {
+  if (value && typeof value === "object" && typeof value.getHexString === "function") {
+    try {
+      return `#${value.getHexString()}`;
+    } catch {
+      return fallback;
+    }
+  }
+  return fallback;
+}
+__name(toHexColor2, "toHexColor");
+function getMaterialType(material) {
+  if (material instanceof THREE5__namespace.MeshPhysicalMaterial) {
+    return "physical";
+  }
+  if (material instanceof THREE5__namespace.MeshPhongMaterial) {
+    return "phong";
+  }
+  if (material instanceof THREE5__namespace.MeshBasicMaterial) {
+    return "basic";
+  }
+  return "standard";
+}
+__name(getMaterialType, "getMaterialType");
+function textureImageSrc(texture) {
+  const src = texture?.image?.src;
+  return typeof src === "string" ? src : void 0;
+}
+__name(textureImageSrc, "textureImageSrc");
+function textureSourceUrl(texture) {
+  if (!texture?.image) {
+    return void 0;
+  }
+  const currentSrc = texture.source?.data?.currentSrc;
+  if (typeof currentSrc === "string" && currentSrc) {
+    return currentSrc;
+  }
+  return textureImageSrc(texture);
+}
+__name(textureSourceUrl, "textureSourceUrl");
+function createMaterialValue(material) {
+  const materialRecord = material;
+  const normalScale = materialRecord.normalScale;
+  const map = materialRecord.map;
+  return {
+    type: getMaterialType(material),
+    color: toHexColor2(materialRecord.color, "#ffffff"),
+    roughness: typeof materialRecord.roughness === "number" ? materialRecord.roughness : 0.5,
+    metalness: typeof materialRecord.metalness === "number" ? materialRecord.metalness : 0.5,
+    normalScale: typeof normalScale?.x === "number" ? normalScale.x : 1,
+    opacity: typeof materialRecord.opacity === "number" ? materialRecord.opacity : 1,
+    emissive: toHexColor2(materialRecord.emissive, "#000000"),
+    emissiveIntensity: typeof materialRecord.emissiveIntensity === "number" ? materialRecord.emissiveIntensity : 0,
+    side: typeof materialRecord.side === "number" ? materialRecord.side : THREE5__namespace.FrontSide,
+    blending: typeof materialRecord.blending === "number" ? materialRecord.blending : THREE5__namespace.NormalBlending,
+    depthTest: materialRecord.depthTest !== false,
+    depthWrite: materialRecord.depthWrite !== false,
+    wireframe: Boolean(materialRecord.wireframe),
+    transparent: Boolean(materialRecord.transparent),
+    textureMap: textureSourceUrl(map),
+    alphaTextureMap: textureImageSrc(
+      materialRecord.alphaMap
+    ),
+    normalMap: textureImageSrc(
+      materialRecord.normalMap
+    ),
+    roughnessMap: textureImageSrc(
+      materialRecord.roughnessMap
+    ),
+    metalnessMap: textureImageSrc(
+      materialRecord.metalnessMap
+    ),
+    aoMap: textureImageSrc(materialRecord.aoMap),
+    emissiveMap: textureImageSrc(
+      materialRecord.emissiveMap
+    ),
+    bumpMap: textureImageSrc(
+      materialRecord.bumpMap
+    ),
+    displacementMap: textureImageSrc(
+      materialRecord.displacementMap
+    ),
+    lightMap: textureImageSrc(
+      materialRecord.lightMap
+    ),
+    envMap: textureImageSrc(materialRecord.envMap),
+    textureFiltering: map?.magFilter === THREE5__namespace.NearestFilter ? "sharp" : "smooth",
+    useMipmaps: map?.generateMipmaps !== false
+  };
+}
+__name(createMaterialValue, "createMaterialValue");
+function defaultMaterialValue() {
+  return {
+    type: "standard",
+    color: "#ffffff",
+    roughness: 0.5,
+    metalness: 0.5,
+    normalScale: 1,
+    opacity: 1,
+    emissive: "#000000",
+    emissiveIntensity: 0,
+    side: THREE5__namespace.FrontSide,
+    blending: THREE5__namespace.NormalBlending,
+    depthTest: true,
+    depthWrite: true,
+    wireframe: false,
+    transparent: false,
+    textureFiltering: "smooth",
+    useMipmaps: true
+  };
+}
+__name(defaultMaterialValue, "defaultMaterialValue");
+var _MaterialComponent = class _MaterialComponent extends Component {
+  constructor(materialOrMaterials = []) {
+    super();
+    this.materials = [];
+    this.material = null;
+    this.values = [];
+    this.assetRefs = [];
+    this.setMaterials(materialOrMaterials);
+  }
+  /** Link/unlink a slot to a material asset URL (editor bookkeeping only). */
+  setAssetRef(index, url) {
+    if (index < 0) {
+      return;
+    }
+    while (this.assetRefs.length <= index) {
+      this.assetRefs.push(null);
+    }
+    this.assetRefs[index] = url;
+  }
+  /** The material-asset URL a slot is linked to, or null when local. */
+  getAssetRef(index) {
+    return this.assetRefs[index] ?? null;
+  }
+  setMaterials(materialOrMaterials = []) {
+    this.materials = Array.isArray(materialOrMaterials) ? materialOrMaterials.filter(Boolean) : materialOrMaterials ? [materialOrMaterials] : [];
+    this.material = this.materials[0] ?? null;
+    this.values = this.materials.length > 0 ? this.materials.map((material) => createMaterialValue(material)) : [defaultMaterialValue()];
+  }
+  updateValue(index, patch) {
+    if (index < 0) {
+      return;
+    }
+    while (this.values.length <= index) {
+      this.values.push(defaultMaterialValue());
+    }
+    this.values[index] = {
+      ...this.values[index],
+      ...patch
+    };
+  }
+  resetValue(index) {
+    if (index < 0) {
+      return;
+    }
+    while (this.values.length <= index) {
+      this.values.push(defaultMaterialValue());
+    }
+    const type = this.values[index]?.type ?? "standard";
+    this.values[index] = {
+      ...defaultMaterialValue(),
+      type
+    };
+  }
+  setMaterialType(index, type) {
+    this.updateValue(index, { type });
+  }
+  setTextureFiltering(index, filtering) {
+    this.updateValue(index, { textureFiltering: filtering });
+  }
+  setUseMipmaps(index, enabled) {
+    this.updateValue(index, { useMipmaps: enabled });
+  }
+};
+__name(_MaterialComponent, "MaterialComponent");
+var MaterialComponent = _MaterialComponent;
+
+// core/components/Model.ts
+var MODEL_NO_PATH_MESSAGE = "No model path set.";
+function setModelLoadState(component, state, error) {
+  Object.defineProperty(component, "loadState", {
+    value: state,
+    writable: true,
+    configurable: true,
+    enumerable: false
+  });
+  Object.defineProperty(component, "loadError", {
+    value: state === "error" ? error ?? "Failed to load model." : void 0,
+    writable: true,
+    configurable: true,
+    enumerable: false
+  });
+}
+__name(setModelLoadState, "setModelLoadState");
+var _ModelComponent = class _ModelComponent extends Component {
+  constructor(path) {
+    super();
+    this.path = path;
+    this.object = null;
+    if (path) {
+      setModelLoadState(this, "loading");
+    } else {
+      setModelLoadState(this, "error", MODEL_NO_PATH_MESSAGE);
+    }
+  }
+};
+__name(_ModelComponent, "ModelComponent");
+var ModelComponent = _ModelComponent;
+
+// core/components/Name.ts
+var _Name = class _Name extends Component {
+  constructor(value) {
+    super();
+    this.value = value;
+  }
+};
+__name(_Name, "Name");
+var Name = _Name;
+
+// core/components/Object3DRef.ts
+var _Object3DRef = class _Object3DRef extends Component {
+  constructor(object, visibility) {
+    super();
+    this.object = object;
+    this.visibility = typeof visibility === "boolean" ? visibility : Boolean(object.visible);
+  }
+};
+__name(_Object3DRef, "Object3DRef");
+var Object3DRef = _Object3DRef;
+
+// core/components/ParentId.ts
+var _ParentId = class _ParentId extends Component {
+  constructor(value = null) {
+    super();
+    this.value = value;
+  }
+};
+__name(_ParentId, "ParentId");
+var ParentId = _ParentId;
+
+// core/components/PrefabInstance.ts
+var generateInstanceId = /* @__PURE__ */ __name(() => {
+  try {
+    return crypto.randomUUID();
+  } catch {
+    return `i-${Math.random().toString(36).slice(2, 10)}${Date.now().toString(36)}`;
+  }
+}, "generateInstanceId");
+var _PrefabInstance = class _PrefabInstance extends Component {
+  constructor(url, overrides = [], instanceId) {
+    super();
+    this.url = url;
+    this.overrides = overrides;
+    this.instanceId = typeof instanceId === "string" && instanceId.length > 0 ? instanceId : generateInstanceId();
+  }
+};
+__name(_PrefabInstance, "PrefabInstance");
+var PrefabInstance = _PrefabInstance;
+
+// core/components/PrefabNode.ts
+var _PrefabNode = class _PrefabNode extends Component {
+  constructor(nodeId) {
+    super();
+    this.nodeId = nodeId;
+  }
+};
+__name(_PrefabNode, "PrefabNode");
+var PrefabNode = _PrefabNode;
+
+// core/components/ScriptComponent.ts
+var _ScriptComponent = class _ScriptComponent extends Component {
+  constructor(entries = []) {
+    super();
+    this.entries = entries.map((entry) => ({
+      entityId: typeof entry.entityId === "number" ? entry.entityId : 0,
+      className: typeof entry.className === "string" ? entry.className : "",
+      scriptUrl: typeof entry.scriptUrl === "string" ? entry.scriptUrl : "",
+      enabled: typeof entry.enabled === "boolean" ? entry.enabled : true,
+      data: entry.data && typeof entry.data === "object" && !Array.isArray(entry.data) ? entry.data : {},
+      runtimeState: entry.runtimeState,
+      runtimeMessage: typeof entry.runtimeMessage === "string" ? entry.runtimeMessage : void 0
+    }));
+    Object.defineProperty(this, "scriptInstance", {
+      value: null,
+      writable: true,
+      configurable: true,
+      enumerable: false
+    });
+    Object.defineProperty(this, "scriptInstances", {
+      value: /* @__PURE__ */ new Map(),
+      writable: true,
+      configurable: true,
+      enumerable: false
+    });
+  }
+};
+__name(_ScriptComponent, "ScriptComponent");
+var ScriptComponent = _ScriptComponent;
+
+// core/components/ScriptObjectComponent.ts
+var _ScriptObjectComponent = class _ScriptObjectComponent extends Component {
+  constructor(input = {}) {
+    super();
+    this.scriptUrl = typeof input.scriptUrl === "string" && input.scriptUrl.length > 0 ? input.scriptUrl : null;
+    this.className = typeof input.className === "string" && input.className.length > 0 ? input.className : null;
+    this.enabled = typeof input.enabled === "boolean" ? input.enabled : true;
+    this.data = input.data && typeof input.data === "object" && !Array.isArray(input.data) ? input.data : {};
+    this.runtimeState = input.runtimeState === "idle" || input.runtimeState === "loading" || input.runtimeState === "ready" || input.runtimeState === "error" ? input.runtimeState : "idle";
+    this.runtimeMessage = typeof input.runtimeMessage === "string" ? input.runtimeMessage : void 0;
+    Object.defineProperty(this, "instance", {
+      value: null,
+      writable: true,
+      configurable: true,
+      enumerable: false
+    });
+  }
+};
+__name(_ScriptObjectComponent, "ScriptObjectComponent");
+var ScriptObjectComponent = _ScriptObjectComponent;
+
+// core/components/Selectable.ts
+var _Selectable = class _Selectable extends Component {
+  constructor(enabled = true) {
+    super();
+    this.enabled = enabled;
+  }
+};
+__name(_Selectable, "Selectable");
+var Selectable = _Selectable;
+
+// core/components/Sprite.ts
+var _SpriteComponent = class _SpriteComponent extends Component {
+  constructor(path, width = 1, height = 1) {
+    super();
+    this.path = path;
+    this.width = width;
+    this.height = height;
+    this.texture = null;
+    this.object = null;
+  }
+};
+__name(_SpriteComponent, "SpriteComponent");
+var SpriteComponent = _SpriteComponent;
+function readXYZ(input) {
+  return {
+    x: input.x,
+    y: input.y,
+    z: input.z
+  };
+}
+__name(readXYZ, "readXYZ");
+var _TransformComponent = class _TransformComponent extends Component {
+  constructor(data = {}) {
+    super();
+    const position = data.position ?? {};
+    const rotation = data.rotation ?? {};
+    const scale = data.scale ?? {};
+    this.position = {
+      x: position.x ?? 0,
+      y: position.y ?? 0,
+      z: position.z ?? 0
+    };
+    this.rotation = {
+      x: rotation.x ?? 0,
+      y: rotation.y ?? 0,
+      z: rotation.z ?? 0
+    };
+    this.scale = {
+      x: scale.x ?? 1,
+      y: scale.y ?? 1,
+      z: scale.z ?? 1
+    };
+  }
+  toPositionVector3(target = new THREE5.Vector3()) {
+    return target.set(this.position.x, this.position.y, this.position.z);
+  }
+  toRotationEuler(target = new THREE5.Euler(), order = "XYZ") {
+    return target.set(this.rotation.x, this.rotation.y, this.rotation.z, order);
+  }
+  toRotationQuaternion(target = new THREE5.Quaternion(), order = "XYZ") {
+    const euler2 = new THREE5.Euler(
+      this.rotation.x,
+      this.rotation.y,
+      this.rotation.z,
+      order
+    );
+    return target.setFromEuler(euler2);
+  }
+  toScaleVector3(target = new THREE5.Vector3()) {
+    return target.set(this.scale.x, this.scale.y, this.scale.z);
+  }
+  setPosition(input) {
+    const next = readXYZ(input);
+    this.position.x = next.x;
+    this.position.y = next.y;
+    this.position.z = next.z;
+    return this;
+  }
+  setScale(input) {
+    const next = readXYZ(input);
+    this.scale.x = next.x;
+    this.scale.y = next.y;
+    this.scale.z = next.z;
+    return this;
+  }
+  setRotation(input, order = "XYZ") {
+    if (input instanceof THREE5.Quaternion) {
+      const euler2 = new THREE5.Euler().setFromQuaternion(input, order);
+      this.rotation.x = euler2.x;
+      this.rotation.y = euler2.y;
+      this.rotation.z = euler2.z;
+      return this;
+    }
+    const next = readXYZ(input);
+    this.rotation.x = next.x;
+    this.rotation.y = next.y;
+    this.rotation.z = next.z;
+    return this;
+  }
+};
+__name(_TransformComponent, "TransformComponent");
+var TransformComponent = _TransformComponent;
+
+// core/components/Video.ts
+var DEFAULT_VIDEO_OPTIONS = {
+  autoplay: false,
+  loop: true,
+  volume: 1,
+  width: 1,
+  height: 1,
+  isGreenScreen: false,
+  backgroundColor: "#00ff00",
+  similarity: 0.4,
+  smoothness: 0.08,
+  spill: 0.12,
+  /** When `true`, the video's audio stream is spatialized using the entity's transform. */
+  positional: false,
+  /** Distance at which volume is unattenuated (positional only). */
+  refDistance: 1,
+  /** WebAudio distance model (`linear`, `inverse`, `exponential`). Positional only. */
+  distanceModel: "inverse",
+  /** How quickly volume falls off past `refDistance`. Positional only. */
+  rolloffFactor: 1
+};
+var _VideoComponent = class _VideoComponent extends Component {
+  constructor(path, options = {}) {
+    super();
+    this.path = path;
+    this.options = {
+      ...DEFAULT_VIDEO_OPTIONS,
+      ...options
+    };
+    this.object = null;
+    this.videoElement = null;
+    this.texture = null;
+    this.material = null;
+    this.audioNode = null;
+    Object.defineProperty(this, "isPlaying", {
+      value: false,
+      writable: true,
+      configurable: true,
+      enumerable: false
+    });
+    Object.defineProperty(this, "isPaused", {
+      value: false,
+      writable: true,
+      configurable: true,
+      enumerable: false
+    });
+  }
+  /**
+   * Signals `VideoSystem` to start (or resume) playback.
+   * Has no direct effect in the editor — `VideoSystem` drives the actual
+   * HTML video element call in preview.
+   */
+  play() {
+    this.isPlaying = true;
+    this.isPaused = false;
+  }
+  /**
+   * Signals `VideoSystem` to pause playback, preserving the current position.
+   * Calling {@link play} afterwards resumes from where it paused.
+   * No-op if not currently playing.
+   */
+  pause() {
+    if (!this.isPlaying) return;
+    this.isPlaying = false;
+    this.isPaused = true;
+  }
+  /**
+   * Signals `VideoSystem` to stop playback and reset the playback position.
+   */
+  stop() {
+    this.isPlaying = false;
+    this.isPaused = false;
+  }
+};
+__name(_VideoComponent, "VideoComponent");
+var VideoComponent = _VideoComponent;
+
+// core/components/VRTeleportArea.ts
+var _VRTeleportAreaComponent = class _VRTeleportAreaComponent extends Component {
+  constructor(options) {
+    super();
+    this.enabled = options?.enabled ?? true;
+    const shape = options?.shape;
+    this.shape = shape === "cylinder" ? "circle" : options?.shape ?? "plane";
+    this.width = options?.width ?? 10;
+    this.depth = options?.depth ?? 10;
+  }
+};
+__name(_VRTeleportAreaComponent, "VRTeleportAreaComponent");
+var VRTeleportAreaComponent = _VRTeleportAreaComponent;
+
+// core/components/XRInteractable.ts
+var _XRInteractableComponent = class _XRInteractableComponent extends Component {
+  constructor(options) {
+    super();
+    this.enabled = options?.enabled ?? true;
+    this.grabbable = options?.grabbable ?? true;
+    this.pointable = options?.pointable ?? true;
+    this.grabReach = options?.grabReach ?? "both";
+    this.distanceBehavior = options?.distanceBehavior ?? "snap";
+    this.grabGesture = options?.grabGesture ?? "any";
+    this.grabRadius = options?.grabRadius ?? 0.15;
+    this.grabOffsetPosition = options?.grabOffsetPosition ?? {
+      x: 0,
+      y: 0,
+      z: 0
+    };
+    this.grabOffsetRotation = options?.grabOffsetRotation ?? {
+      x: 0,
+      y: 0,
+      z: 0
+    };
+    this.grabHands = options?.grabHands ?? "handOff";
+    this.twoHandRotation = options?.twoHandRotation ?? "align";
+    this.allowTwoHandScale = options?.allowTwoHandScale ?? false;
+    this.minScale = options?.minScale ?? 0.25;
+    this.maxScale = options?.maxScale ?? 4;
+    this.attachPoints = (options?.attachPoints ?? []).map(
+      (point) => createAttachPoint(point)
+    );
+    this.applyVelocityOnRelease = options?.applyVelocityOnRelease ?? true;
+    this.velocityScale = options?.velocityScale ?? 1;
+    this.hoverBehavior = options?.hoverBehavior ?? "color";
+    this.hoverColor = options?.hoverColor ?? "#4da3ff";
+    this.hoverScale = options?.hoverScale ?? 1.06;
+  }
+};
+__name(_XRInteractableComponent, "XRInteractableComponent");
+var XRInteractableComponent = _XRInteractableComponent;
+function createAttachPoint(partial) {
+  return {
+    id: partial.id,
+    name: partial.name ?? partial.id,
+    position: { x: 0, y: 0, z: 0, ...partial.position },
+    rotation: { x: 0, y: 0, z: 0, ...partial.rotation },
+    hand: partial.hand ?? "any",
+    role: partial.role ?? "any"
+  };
+}
+__name(createAttachPoint, "createAttachPoint");
+
+// core/components/XRRig.ts
+var _XRRigComponent = class _XRRigComponent extends Component {
+  constructor(options) {
+    super();
+    this.trackingOrigin = options?.trackingOrigin ?? "floor";
+    this.locomotion = options?.locomotion ?? "teleport";
+    this.moveSpeed = options?.moveSpeed ?? 2;
+    this.snapTurn = options?.snapTurn ?? true;
+    this.snapTurnDegrees = options?.snapTurnDegrees ?? 30;
+    this.fallbackEyeHeight = options?.fallbackEyeHeight ?? 1.6;
+    this.teleportArcColor = options?.teleportArcColor ?? "#4da3ff";
+    this.teleportArcInvalidColor = options?.teleportArcInvalidColor ?? "#ff5a5a";
+    this.teleportArcThickness = options?.teleportArcThickness ?? 0.012;
+    this.passthrough = options?.passthrough ?? false;
+    this.depthOcclusion = options?.depthOcclusion ?? false;
+    this.environmentPhysics = options?.environmentPhysics ?? "none";
+    this.environmentDebug = options?.environmentDebug ?? false;
+    this.hitTest = options?.hitTest ?? false;
+    this.anchors = options?.anchors ?? false;
+  }
+};
+__name(_XRRigComponent, "XRRigComponent");
+var XRRigComponent = _XRRigComponent;
+
+// core/components/XRAnchor.ts
+var _XRAnchorComponent = class _XRAnchorComponent extends Component {
+  constructor(options) {
+    super();
+    this.enabled = options?.enabled ?? true;
+  }
+};
+__name(_XRAnchorComponent, "XRAnchorComponent");
+var XRAnchorComponent = _XRAnchorComponent;
+
+// core/components/BoneAttachment.ts
+var _BoneAttachmentComponent = class _BoneAttachmentComponent extends Component {
+  constructor(options) {
+    super();
+    this.bone = options?.bone ?? "";
+    this.humanoid = options?.humanoid ?? null;
+    this.compensateScale = options?.compensateScale ?? true;
+    this.enabled = options?.enabled ?? true;
+  }
+};
+__name(_BoneAttachmentComponent, "BoneAttachmentComponent");
+var BoneAttachmentComponent = _BoneAttachmentComponent;
+
+// core/components/Network.ts
+var _NetworkIdentityComponent = class _NetworkIdentityComponent extends Component {
+  constructor() {
+    super();
+    for (const key of ["networkId", "owner"]) {
+      Object.defineProperty(this, key, {
+        value: "",
+        writable: true,
+        configurable: true,
+        enumerable: false
+      });
+    }
+  }
+};
+__name(_NetworkIdentityComponent, "NetworkIdentityComponent");
+var NetworkIdentityComponent = _NetworkIdentityComponent;
+var _NetworkTransformComponent = class _NetworkTransformComponent extends Component {
+  constructor(options = {}) {
+    super();
+    this.enabled = true;
+    /** Updates per second the owner sends. */
+    this.sendRate = 20;
+    /** How far in the past others see it, in ms. More is smoother; less is more current. */
+    this.interpolationMs = 100;
+    this.syncRotation = true;
+    /** A jump longer than this (m) snaps instead of sliding, for respawns and teleports. */
+    this.teleportDistance = 5;
+    Object.assign(this, options);
+  }
+};
+__name(_NetworkTransformComponent, "NetworkTransformComponent");
+var NetworkTransformComponent = _NetworkTransformComponent;
+var _NetworkedPropsComponent = class _NetworkedPropsComponent extends Component {
+  constructor(values = {}) {
+    super();
+    this.values = values;
+  }
+};
+__name(_NetworkedPropsComponent, "NetworkedPropsComponent");
+var NetworkedPropsComponent = _NetworkedPropsComponent;
+var _NetworkSpawnerComponent = class _NetworkSpawnerComponent extends Component {
+  constructor(playerPrefab = "", spawnRadius = 2) {
+    super();
+    this.playerPrefab = playerPrefab;
+    this.spawnRadius = spawnRadius;
+  }
+};
+__name(_NetworkSpawnerComponent, "NetworkSpawnerComponent");
+var NetworkSpawnerComponent = _NetworkSpawnerComponent;
+
+// core/components/IK.ts
+function normalizeIKChain(chain) {
+  const weight = typeof chain.weight === "number" && Number.isFinite(chain.weight) ? chain.weight : 1;
+  return {
+    limb: chain.limb,
+    target: typeof chain.target === "number" ? chain.target : null,
+    pole: typeof chain.pole === "number" ? chain.pole : null,
+    weight: Math.min(1, Math.max(0, weight)),
+    matchRotation: chain.matchRotation ?? false,
+    enabled: chain.enabled ?? true
+  };
+}
+__name(normalizeIKChain, "normalizeIKChain");
+var _IKComponent = class _IKComponent extends Component {
+  constructor(options) {
+    super();
+    this.chains = (options?.chains ?? []).map(normalizeIKChain);
+    this.enabled = options?.enabled ?? true;
+  }
+};
+__name(_IKComponent, "IKComponent");
+var IKComponent = _IKComponent;
+
+// core/components/UIPanel.ts
+var _UIPanelComponent = class _UIPanelComponent extends Component {
+  constructor(options) {
+    super();
+    this.width = options?.width ?? 0.6;
+    this.height = options?.height ?? 0.4;
+    this.backgroundColor = options?.backgroundColor ?? "#1c1c1c";
+    this.backgroundOpacity = options?.backgroundOpacity ?? 0.92;
+    this.cornerRadius = options?.cornerRadius ?? 0.02;
+    this.borderWidth = options?.borderWidth ?? 0;
+    this.borderColor = options?.borderColor ?? "#333333";
+    this.pixelDensity = options?.pixelDensity ?? 1024;
+    this.follow = options?.follow ?? "world";
+  }
+};
+__name(_UIPanelComponent, "UIPanelComponent");
+var UIPanelComponent = _UIPanelComponent;
+
+// core/components/UIText.ts
+var _UITextComponent = class _UITextComponent extends Component {
+  constructor(options) {
+    super();
+    this.text = options?.text ?? "Text";
+    this.width = options?.width ?? 0.5;
+    this.height = options?.height ?? 0.12;
+    this.fontSize = options?.fontSize ?? 0.035;
+    this.fontWeight = options?.fontWeight ?? 500;
+    this.color = options?.color ?? "#ffffff";
+    this.align = options?.align ?? "center";
+    this.valign = options?.valign ?? "middle";
+    this.lineHeight = options?.lineHeight ?? 1.25;
+    this.padding = options?.padding ?? 0.01;
+  }
+};
+__name(_UITextComponent, "UITextComponent");
+var UITextComponent = _UITextComponent;
+
+// core/components/UIButton.ts
+var _UIButtonComponent = class _UIButtonComponent extends Component {
+  constructor(options) {
+    super();
+    this.label = options?.label ?? "Button";
+    this.actionId = options?.actionId ?? "";
+    this.width = options?.width ?? 0.3;
+    this.height = options?.height ?? 0.1;
+    this.fontSize = options?.fontSize ?? 0.03;
+    this.fontWeight = options?.fontWeight ?? 600;
+    this.textColor = options?.textColor ?? "#ffffff";
+    this.backgroundColor = options?.backgroundColor ?? "#2a2a2a";
+    this.backgroundOpacity = options?.backgroundOpacity ?? 1;
+    this.cornerRadius = options?.cornerRadius ?? 0.02;
+    this.borderWidth = options?.borderWidth ?? 2e-3;
+    this.borderColor = options?.borderColor ?? "#3a3a3a";
+  }
+};
+__name(_UIButtonComponent, "UIButtonComponent");
+var UIButtonComponent = _UIButtonComponent;
+
+// core/components/UIToggle.ts
+var _UIToggleComponent = class _UIToggleComponent extends Component {
+  constructor(options) {
+    super();
+    this.value = options?.value ?? false;
+    this.actionId = options?.actionId ?? "";
+    this.width = options?.width ?? 0.14;
+    this.height = options?.height ?? 0.07;
+    this.trackColor = options?.trackColor ?? "#2a2a2a";
+    this.accentColor = options?.accentColor ?? "#ff6b35";
+    this.knobColor = options?.knobColor ?? "#ffffff";
+  }
+};
+__name(_UIToggleComponent, "UIToggleComponent");
+var UIToggleComponent = _UIToggleComponent;
+
+// core/components/UISlider.ts
+var _UISliderComponent = class _UISliderComponent extends Component {
+  constructor(options) {
+    super();
+    this.min = options?.min ?? 0;
+    this.max = options?.max ?? Math.max(1, this.min + 1);
+    if (this.max <= this.min) this.max = this.min + 1;
+    const v = options?.value ?? (this.min + this.max) / 2;
+    this.value = Math.min(this.max, Math.max(this.min, v));
+    this.actionId = options?.actionId ?? "";
+    this.width = options?.width ?? 0.4;
+    this.height = options?.height ?? 0.06;
+    this.trackColor = options?.trackColor ?? "#2a2a2a";
+    this.accentColor = options?.accentColor ?? "#ff6b35";
+    this.knobColor = options?.knobColor ?? "#ffffff";
+  }
+};
+__name(_UISliderComponent, "UISliderComponent");
+var UISliderComponent = _UISliderComponent;
+
+// core/components/XRInteractor.ts
+var _XRInteractorComponent = class _XRInteractorComponent extends Component {
+  constructor(options) {
+    super();
+    this.interactorType = options?.interactorType ?? "both";
+    this.handPreset = options?.handPreset ?? "default";
+    this.handColor = options?.handColor ?? "#e8b48a";
+    this.handOpacity = options?.handOpacity ?? 1;
+    this.handEmissiveIntensity = options?.handEmissiveIntensity ?? 0;
+    this.rayVisibility = options?.rayVisibility ?? "interacting";
+    this.rayColor = options?.rayColor ?? "#4da3ff";
+    this.rayThickness = options?.rayThickness ?? 6e-3;
+  }
+};
+__name(_XRInteractorComponent, "XRInteractorComponent");
+var XRInteractorComponent = _XRInteractorComponent;
+var _XRInteractorSideComponent = class _XRInteractorSideComponent extends Component {
+  constructor(options) {
+    super();
+    this.side = options?.side ?? "left";
+  }
+};
+__name(_XRInteractorSideComponent, "XRInteractorSideComponent");
+var XRInteractorSideComponent = _XRInteractorSideComponent;
+
+// core/components/XRHandPose.ts
+var DEFAULT_POSE_CURLS = {
+  thumb: 0,
+  index: 0,
+  middle: 0,
+  ring: 0,
+  pinky: 0
+};
+function createHandPoseEntry(partial) {
+  return {
+    id: partial.id,
+    name: partial.name ?? partial.id,
+    preset: partial.preset ?? null,
+    curls: { ...DEFAULT_POSE_CURLS, ...partial.curls },
+    tolerance: partial.tolerance ?? 0.25,
+    directions: {
+      thumb: [...partial.directions?.thumb ?? []],
+      index: [...partial.directions?.index ?? []],
+      middle: [...partial.directions?.middle ?? []],
+      ring: [...partial.directions?.ring ?? []],
+      pinky: [...partial.directions?.pinky ?? []]
+    },
+    directionTolerance: partial.directionTolerance ?? 45,
+    hand: partial.hand ?? null,
+    orientation: partial.orientation ?? null,
+    minHoldSeconds: partial.minHoldSeconds ?? 0.15,
+    enabled: partial.enabled ?? true
+  };
+}
+__name(createHandPoseEntry, "createHandPoseEntry");
+var _XRHandPoseComponent = class _XRHandPoseComponent extends Component {
+  constructor(options) {
+    super();
+    this.enabled = options?.enabled ?? true;
+    this.poses = (options?.poses ?? []).map((pose) => createHandPoseEntry(pose));
+  }
+};
+__name(_XRHandPoseComponent, "XRHandPoseComponent");
+var XRHandPoseComponent = _XRHandPoseComponent;
+new THREE5__namespace.Vector3();
+new THREE5__namespace.Vector3();
+function applyTransform(object, transform) {
+  object.position.set(
+    transform.position.x,
+    transform.position.y,
+    transform.position.z
+  );
+  object.rotation.set(
+    transform.rotation.x,
+    transform.rotation.y,
+    transform.rotation.z
+  );
+  object.scale.set(transform.scale.x, transform.scale.y, transform.scale.z);
+}
+__name(applyTransform, "applyTransform");
+
+// core/prefab/collectEntitySubtree.ts
+function collectEntitySubtree(world, rootIds) {
+  const childrenByParent = /* @__PURE__ */ new Map();
+  for (const entityId of world.query(ParentId)) {
+    const parentId = world.getComponent(entityId, ParentId)?.value;
+    if (parentId === null || parentId === void 0) {
+      continue;
+    }
+    const siblings = childrenByParent.get(parentId);
+    if (siblings) {
+      siblings.push(entityId);
+    } else {
+      childrenByParent.set(parentId, [entityId]);
+    }
+  }
+  const ordered = [];
+  const seen = /* @__PURE__ */ new Set();
+  const queue = [...rootIds];
+  while (queue.length > 0) {
+    const entityId = queue.shift();
+    if (seen.has(entityId)) {
+      continue;
+    }
+    seen.add(entityId);
+    ordered.push(entityId);
+    const children = childrenByParent.get(entityId);
+    if (children) {
+      queue.push(...children.sort((a, b) => a - b));
+    }
+  }
+  return ordered;
+}
+__name(collectEntitySubtree, "collectEntitySubtree");
+
+// core/hydration/readers.ts
+function asRecord3(value) {
+  if (!value || typeof value !== "object") {
+    return null;
+  }
+  return value;
+}
+__name(asRecord3, "asRecord");
+function readString(value) {
+  if (typeof value === "string") {
+    return value;
+  }
+  const record = asRecord3(value);
+  if (!record) {
+    return null;
+  }
+  return typeof record.value === "string" ? record.value : null;
+}
+__name(readString, "readString");
+function readTransform(value) {
+  const record = asRecord3(value);
+  if (!record) {
+    return void 0;
+  }
+  const position = asRecord3(record.position);
+  const rotation = asRecord3(record.rotation);
+  const scale = asRecord3(record.scale);
+  return {
+    position: position ? {
+      x: typeof position.x === "number" ? position.x : void 0,
+      y: typeof position.y === "number" ? position.y : void 0,
+      z: typeof position.z === "number" ? position.z : void 0
+    } : void 0,
+    rotation: rotation ? {
+      x: typeof rotation.x === "number" ? rotation.x : void 0,
+      y: typeof rotation.y === "number" ? rotation.y : void 0,
+      z: typeof rotation.z === "number" ? rotation.z : void 0
+    } : void 0,
+    scale: scale ? {
+      x: typeof scale.x === "number" ? scale.x : void 0,
+      y: typeof scale.y === "number" ? scale.y : void 0,
+      z: typeof scale.z === "number" ? scale.z : void 0
+    } : void 0
+  };
+}
+__name(readTransform, "readTransform");
+function readByComponent(components, componentName) {
+  const component = components.find((entry) => entry.component === componentName);
+  const map = /* @__PURE__ */ new Map();
+  if (!component) {
+    return map;
+  }
+  for (const entry of component.entries) {
+    map.set(entry.entityId, entry.value);
+  }
+  return map;
+}
+__name(readByComponent, "readByComponent");
+function readBoolean(value) {
+  return typeof value === "boolean" ? value : void 0;
+}
+__name(readBoolean, "readBoolean");
+function readNumber(value) {
+  return typeof value === "number" ? value : void 0;
+}
+__name(readNumber, "readNumber");
+
+// core/hydration/componentValues.ts
+function buildComponentValueMaps(snapshot) {
+  return {
+    object3DRefValues: readByComponent(snapshot.components, "Object3DRef"),
+    nameValues: readByComponent(snapshot.components, "Name"),
+    transformValues: readByComponent(snapshot.components, "TransformComponent"),
+    modelValues: readByComponent(snapshot.components, "ModelComponent"),
+    imageValues: readByComponent(snapshot.components, "ImageComponent"),
+    spriteValues: readByComponent(snapshot.components, "SpriteComponent"),
+    videoValues: readByComponent(snapshot.components, "VideoComponent"),
+    cameraValues: readByComponent(snapshot.components, "CameraComponent"),
+    environmentValues: readByComponent(snapshot.components, "Environment"),
+    postprocessingValues: readByComponent(snapshot.components, "Postprocessing"),
+    audioValues: readByComponent(snapshot.components, "AudioComponent"),
+    imageTargetValues: readByComponent(snapshot.components, "ImageTarget"),
+    lightValues: readByComponent(snapshot.components, "LightComponent"),
+    materialValues: readByComponent(snapshot.components, "MaterialComponent"),
+    meshGeometryValues: readByComponent(snapshot.components, "MeshGeometryComponent"),
+    selectableValues: readByComponent(snapshot.components, "Selectable"),
+    physicsValues: readByComponent(snapshot.components, "PhysicsComponent"),
+    animationValues: readByComponent(snapshot.components, "AnimationComponent"),
+    imageTargetAnchorValues: readByComponent(snapshot.components, "ImageTargetAnchor"),
+    scriptValues: readByComponent(snapshot.components, "ScriptComponent"),
+    scriptObjectValues: readByComponent(
+      snapshot.components,
+      "ScriptObjectComponent"
+    ),
+    xrRigValues: readByComponent(snapshot.components, "XRRigComponent"),
+    vrTeleportAreaValues: readByComponent(
+      snapshot.components,
+      "VRTeleportAreaComponent"
+    ),
+    xrInteractableValues: readByComponent(
+      snapshot.components,
+      "XRInteractableComponent"
+    ),
+    xrInteractorValues: readByComponent(
+      snapshot.components,
+      "XRInteractorComponent"
+    ),
+    xrHandPoseValues: readByComponent(
+      snapshot.components,
+      "XRHandPoseComponent"
+    ),
+    xrAnchorValues: readByComponent(snapshot.components, "XRAnchorComponent"),
+    boneAttachmentValues: readByComponent(snapshot.components, "BoneAttachmentComponent"),
+    ikValues: readByComponent(snapshot.components, "IKComponent"),
+    networkIdentityValues: readByComponent(snapshot.components, "NetworkIdentityComponent"),
+    networkTransformValues: readByComponent(snapshot.components, "NetworkTransformComponent"),
+    networkedPropsValues: readByComponent(snapshot.components, "NetworkedPropsComponent"),
+    networkSpawnerValues: readByComponent(snapshot.components, "NetworkSpawnerComponent"),
+    uiPanelValues: readByComponent(snapshot.components, "UIPanelComponent"),
+    uiTextValues: readByComponent(snapshot.components, "UITextComponent"),
+    uiButtonValues: readByComponent(snapshot.components, "UIButtonComponent"),
+    uiToggleValues: readByComponent(snapshot.components, "UIToggleComponent"),
+    uiSliderValues: readByComponent(snapshot.components, "UISliderComponent"),
+    xrInteractorSideValues: readByComponent(
+      snapshot.components,
+      "XRInteractorSideComponent"
+    ),
+    instancedMeshValues: readByComponent(snapshot.components, "InstancedMeshComponent"),
+    instanceSlotValues: readByComponent(snapshot.components, "InstanceSlotComponent"),
+    prefabNodeValues: readByComponent(snapshot.components, "PrefabNode"),
+    prefabInstanceValues: readByComponent(snapshot.components, "PrefabInstance")
+  };
+}
+__name(buildComponentValueMaps, "buildComponentValueMaps");
+
+// core/hydration/parentLinks.ts
+function applyParentLinks(snapshot, idMap, objectManagementSystem, world) {
+  const parentValues = readByComponent(snapshot.components, "ParentId");
+  for (const [sourceEntityId, parentValue] of parentValues.entries()) {
+    const targetEntityId = idMap.get(sourceEntityId);
+    if (targetEntityId === void 0) {
+      continue;
+    }
+    const parentRecord = asRecord3(parentValue);
+    const sourceParentId = parentRecord && typeof parentRecord.value === "number" ? parentRecord.value : null;
+    if (sourceParentId === null) {
+      objectManagementSystem.setParent(world, targetEntityId, null, {
+        preserveWorldTransform: false
+      });
+      continue;
+    }
+    const mappedParentId = idMap.get(sourceParentId);
+    objectManagementSystem.setParent(world, targetEntityId, mappedParentId ?? null, {
+      preserveWorldTransform: false
+    });
+  }
+}
+__name(applyParentLinks, "applyParentLinks");
+
+// core/hydration/postCreateComponents.ts
+function remapEntityRefsInScriptData(data, idMap) {
+  const result = {};
+  for (const [key, value] of Object.entries(data)) {
+    if (value !== null && typeof value === "object" && !Array.isArray(value)) {
+      const v = value;
+      if (v.type === "entity" && typeof v.value === "number") {
+        result[key] = { ...v, value: idMap.get(v.value) ?? v.value };
+      } else if (v.type === "component" && v.value !== null && typeof v.value === "object" && !Array.isArray(v.value) && typeof v.value.entityId === "number") {
+        const ref = v.value;
+        result[key] = {
+          ...v,
+          value: { ...ref, entityId: idMap.get(ref.entityId) ?? ref.entityId }
+        };
+      } else {
+        result[key] = value;
+      }
+    } else {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+__name(remapEntityRefsInScriptData, "remapEntityRefsInScriptData");
+function restorePostCreateComponents(world, objectManagementSystem, targetEntityId, sourceEntityId, entityType, values, idMap) {
+  const objectRef = world.getComponent(targetEntityId, Object3DRef)?.object ?? null;
+  const sourceAudio = asRecord3(values.audioValues.get(sourceEntityId));
+  if (sourceAudio && entityType !== "audio") {
+    const sourceOptions = asRecord3(sourceAudio.options) ?? {};
+    objectManagementSystem.createComponentNow(
+      "audio",
+      world,
+      targetEntityId,
+      typeof sourceAudio.path === "string" ? sourceAudio.path : "",
+      sourceOptions,
+      {
+        object: objectRef,
+        listener: objectManagementSystem.getOrCreateAudioListener(),
+        isEditor: objectManagementSystem.isEditorMode()
+      }
+    );
+  }
+  const sourceImageTarget = asRecord3(values.imageTargetValues.get(sourceEntityId));
+  if (sourceImageTarget && entityType !== "imageTarget") {
+    objectManagementSystem.createComponentNow(
+      "imageTarget",
+      world,
+      targetEntityId,
+      {
+        targets: Array.isArray(sourceImageTarget.targets) ? sourceImageTarget.targets : [],
+        compiledTargetUrl: typeof sourceImageTarget.compiledTargetUrl === "string" ? sourceImageTarget.compiledTargetUrl : void 0,
+        compiledTargetDir: typeof sourceImageTarget.compiledTargetDir === "string" ? sourceImageTarget.compiledTargetDir : void 0
+      }
+    );
+  }
+  const sourceImageTargetAnchor = asRecord3(values.imageTargetAnchorValues.get(sourceEntityId));
+  if (sourceImageTargetAnchor) {
+    const mappedTargetId = typeof sourceImageTargetAnchor.targetId === "number" && Number.isFinite(sourceImageTargetAnchor.targetId) ? sourceImageTargetAnchor.targetId : null;
+    objectManagementSystem.createComponentNow("imageTargetAnchor", world, targetEntityId, {
+      targetId: mappedTargetId,
+      targetUrl: typeof sourceImageTargetAnchor.targetUrl === "string" ? sourceImageTargetAnchor.targetUrl : void 0
+    });
+  }
+  const sourceScript = asRecord3(values.scriptValues.get(sourceEntityId));
+  if (sourceScript) {
+    const entries = Array.isArray(sourceScript.entries) ? sourceScript.entries.map((entry) => asRecord3(entry)).filter((entry) => Boolean(entry)).map((entry) => {
+      const runtimeState = entry.runtimeState === "idle" || entry.runtimeState === "loading" || entry.runtimeState === "ready" || entry.runtimeState === "error" ? entry.runtimeState : void 0;
+      return {
+        entityId: targetEntityId,
+        className: typeof entry.className === "string" ? entry.className : "",
+        scriptUrl: typeof entry.scriptUrl === "string" ? entry.scriptUrl : "",
+        enabled: typeof entry.enabled === "boolean" ? entry.enabled : true,
+        data: entry.data && typeof entry.data === "object" && !Array.isArray(entry.data) ? remapEntityRefsInScriptData(entry.data, idMap) : {},
+        runtimeState,
+        runtimeMessage: typeof entry.runtimeMessage === "string" ? entry.runtimeMessage : void 0
+      };
+    }).filter((entry) => entry.className || entry.scriptUrl) : [];
+    if (entries.length) {
+      world.addComponent(targetEntityId, new ScriptComponent(entries));
+    }
+  }
+  const sourceScriptObject = asRecord3(values.scriptObjectValues.get(sourceEntityId));
+  if (sourceScriptObject) {
+    const soc = world.getComponent(targetEntityId, ScriptObjectComponent);
+    const data = asRecord3(sourceScriptObject.data);
+    if (soc && data) {
+      soc.data = remapEntityRefsInScriptData(data, idMap);
+    }
+  }
+  {
+    const sourceXrRig = asRecord3(values.xrRigValues.get(sourceEntityId));
+    const rig = world.getComponent(targetEntityId, XRRigComponent);
+    if (sourceXrRig && rig) {
+      if (typeof sourceXrRig.locomotion === "string") {
+        rig.locomotion = sourceXrRig.locomotion;
+      }
+      if (typeof sourceXrRig.moveSpeed === "number") {
+        rig.moveSpeed = sourceXrRig.moveSpeed;
+      }
+      if (typeof sourceXrRig.snapTurn === "boolean") {
+        rig.snapTurn = sourceXrRig.snapTurn;
+      }
+      if (typeof sourceXrRig.snapTurnDegrees === "number") {
+        rig.snapTurnDegrees = sourceXrRig.snapTurnDegrees;
+      }
+      if (typeof sourceXrRig.teleportArcColor === "string") {
+        rig.teleportArcColor = sourceXrRig.teleportArcColor;
+      }
+      if (typeof sourceXrRig.teleportArcInvalidColor === "string") {
+        rig.teleportArcInvalidColor = sourceXrRig.teleportArcInvalidColor;
+      }
+      if (typeof sourceXrRig.teleportArcThickness === "number") {
+        rig.teleportArcThickness = sourceXrRig.teleportArcThickness;
+      }
+      if (typeof sourceXrRig.fallbackEyeHeight === "number") {
+        rig.fallbackEyeHeight = sourceXrRig.fallbackEyeHeight;
+      }
+      if (typeof sourceXrRig.passthrough === "boolean") {
+        rig.passthrough = sourceXrRig.passthrough;
+      }
+      if (typeof sourceXrRig.depthOcclusion === "boolean") {
+        rig.depthOcclusion = sourceXrRig.depthOcclusion;
+      }
+      if (typeof sourceXrRig.environmentPhysics === "string") {
+        rig.environmentPhysics = sourceXrRig.environmentPhysics;
+      }
+      if (typeof sourceXrRig.environmentDebug === "boolean") {
+        rig.environmentDebug = sourceXrRig.environmentDebug;
+      }
+      if (typeof sourceXrRig.hitTest === "boolean") {
+        rig.hitTest = sourceXrRig.hitTest;
+      }
+      if (typeof sourceXrRig.anchors === "boolean") {
+        rig.anchors = sourceXrRig.anchors;
+      }
+    }
+  }
+  {
+    const sourceArea = asRecord3(values.vrTeleportAreaValues.get(sourceEntityId));
+    const area = world.getComponent(targetEntityId, VRTeleportAreaComponent);
+    if (sourceArea && area) {
+      if (typeof sourceArea.enabled === "boolean") {
+        area.enabled = sourceArea.enabled;
+      }
+      if (typeof sourceArea.shape === "string") {
+        area.shape = sourceArea.shape === "cylinder" ? "circle" : sourceArea.shape;
+      }
+      if (typeof sourceArea.width === "number") area.width = sourceArea.width;
+      if (typeof sourceArea.depth === "number") area.depth = sourceArea.depth;
+    }
+  }
+  {
+    const sourceInteractable = asRecord3(
+      values.xrInteractableValues.get(sourceEntityId)
+    );
+    let interactable = world.getComponent(
+      targetEntityId,
+      XRInteractableComponent
+    );
+    if (sourceInteractable && !interactable) {
+      interactable = new XRInteractableComponent();
+      world.addComponent(targetEntityId, interactable);
+    }
+    if (sourceInteractable && interactable) {
+      if (typeof sourceInteractable.enabled === "boolean") {
+        interactable.enabled = sourceInteractable.enabled;
+      }
+      if (typeof sourceInteractable.grabbable === "boolean") {
+        interactable.grabbable = sourceInteractable.grabbable;
+      }
+      if (typeof sourceInteractable.pointable === "boolean") {
+        interactable.pointable = sourceInteractable.pointable;
+      }
+      if (typeof sourceInteractable.grabReach === "string") {
+        interactable.grabReach = sourceInteractable.grabReach;
+      }
+      if (typeof sourceInteractable.distanceBehavior === "string") {
+        interactable.distanceBehavior = sourceInteractable.distanceBehavior;
+      }
+      if (typeof sourceInteractable.grabGesture === "string") {
+        interactable.grabGesture = sourceInteractable.grabGesture;
+      }
+      if (typeof sourceInteractable.grabRadius === "number") {
+        interactable.grabRadius = sourceInteractable.grabRadius;
+      }
+      if (typeof sourceInteractable.grabHands === "string") {
+        interactable.grabHands = sourceInteractable.grabHands;
+      }
+      if (typeof sourceInteractable.twoHandRotation === "string") {
+        interactable.twoHandRotation = sourceInteractable.twoHandRotation;
+      }
+      if (typeof sourceInteractable.allowTwoHandScale === "boolean") {
+        interactable.allowTwoHandScale = sourceInteractable.allowTwoHandScale;
+      }
+      if (typeof sourceInteractable.minScale === "number") {
+        interactable.minScale = sourceInteractable.minScale;
+      }
+      if (typeof sourceInteractable.maxScale === "number") {
+        interactable.maxScale = sourceInteractable.maxScale;
+      }
+      if (Array.isArray(sourceInteractable.attachPoints)) {
+        interactable.attachPoints = sourceInteractable.attachPoints.map((point) => asRecord3(point)).filter(
+          (point) => point !== null && typeof point.id === "string"
+        ).map(
+          (point) => createAttachPoint(
+            point
+          )
+        );
+      }
+      if (typeof sourceInteractable.applyVelocityOnRelease === "boolean") {
+        interactable.applyVelocityOnRelease = sourceInteractable.applyVelocityOnRelease;
+      } else if (typeof sourceInteractable.throwOnRelease === "boolean") {
+        interactable.applyVelocityOnRelease = sourceInteractable.throwOnRelease;
+      }
+      if (typeof sourceInteractable.velocityScale === "number") {
+        interactable.velocityScale = sourceInteractable.velocityScale;
+      } else if (typeof sourceInteractable.throwStrength === "number") {
+        interactable.velocityScale = sourceInteractable.throwStrength;
+      }
+      const grabPos = asRecord3(sourceInteractable.grabOffsetPosition);
+      if (grabPos) {
+        interactable.grabOffsetPosition = {
+          x: typeof grabPos.x === "number" ? grabPos.x : 0,
+          y: typeof grabPos.y === "number" ? grabPos.y : 0,
+          z: typeof grabPos.z === "number" ? grabPos.z : 0
+        };
+      }
+      const grabRot = asRecord3(sourceInteractable.grabOffsetRotation);
+      if (grabRot) {
+        interactable.grabOffsetRotation = {
+          x: typeof grabRot.x === "number" ? grabRot.x : 0,
+          y: typeof grabRot.y === "number" ? grabRot.y : 0,
+          z: typeof grabRot.z === "number" ? grabRot.z : 0
+        };
+      }
+      if (typeof sourceInteractable.hoverBehavior === "string") {
+        interactable.hoverBehavior = sourceInteractable.hoverBehavior;
+      } else if (sourceInteractable.highlightOnHover === false) {
+        interactable.hoverBehavior = "none";
+      }
+      if (typeof sourceInteractable.hoverColor === "string") {
+        interactable.hoverColor = sourceInteractable.hoverColor;
+      }
+      if (typeof sourceInteractable.hoverScale === "number") {
+        interactable.hoverScale = sourceInteractable.hoverScale;
+      }
+    }
+  }
+  {
+    const sourceHandPose = asRecord3(
+      values.xrHandPoseValues.get(sourceEntityId)
+    );
+    let handPose = world.getComponent(targetEntityId, XRHandPoseComponent);
+    if (sourceHandPose && !handPose) {
+      handPose = new XRHandPoseComponent();
+      world.addComponent(targetEntityId, handPose);
+    }
+    if (sourceHandPose && handPose) {
+      if (typeof sourceHandPose.enabled === "boolean") {
+        handPose.enabled = sourceHandPose.enabled;
+      }
+      if (Array.isArray(sourceHandPose.poses)) {
+        handPose.poses = sourceHandPose.poses.map((entry) => asRecord3(entry)).filter(
+          (entry) => entry !== null && typeof entry.id === "string"
+        ).map(
+          (entry) => createHandPoseEntry(
+            entry
+          )
+        );
+      }
+    }
+  }
+  {
+    const sourceAnchor = asRecord3(values.xrAnchorValues.get(sourceEntityId));
+    let anchor = world.getComponent(targetEntityId, XRAnchorComponent);
+    if (sourceAnchor && !anchor) {
+      anchor = new XRAnchorComponent();
+      world.addComponent(targetEntityId, anchor);
+    }
+    if (sourceAnchor && anchor) {
+      if (typeof sourceAnchor.enabled === "boolean") {
+        anchor.enabled = sourceAnchor.enabled;
+      }
+    }
+  }
+  {
+    const source = asRecord3(values.boneAttachmentValues.get(sourceEntityId));
+    if (source) {
+      let attachment = world.getComponent(targetEntityId, BoneAttachmentComponent);
+      if (!attachment) {
+        attachment = new BoneAttachmentComponent();
+        world.addComponent(targetEntityId, attachment);
+      }
+      if (typeof source.bone === "string") attachment.bone = source.bone;
+      if (typeof source.humanoid === "string" || source.humanoid === null) attachment.humanoid = source.humanoid;
+      if (typeof source.compensateScale === "boolean") attachment.compensateScale = source.compensateScale;
+      if (typeof source.enabled === "boolean") attachment.enabled = source.enabled;
+    }
+  }
+  if (values.networkIdentityValues.has(sourceEntityId) && !world.getComponent(targetEntityId, NetworkIdentityComponent)) {
+    world.addComponent(targetEntityId, new NetworkIdentityComponent());
+  }
+  {
+    const source = asRecord3(values.networkTransformValues.get(sourceEntityId));
+    if (source) {
+      let net = world.getComponent(targetEntityId, NetworkTransformComponent);
+      if (!net) {
+        net = new NetworkTransformComponent();
+        world.addComponent(targetEntityId, net);
+      }
+      if (typeof source.enabled === "boolean") net.enabled = source.enabled;
+      if (typeof source.sendRate === "number") net.sendRate = source.sendRate;
+      if (typeof source.interpolationMs === "number") {
+        net.interpolationMs = source.interpolationMs;
+      }
+      if (typeof source.syncRotation === "boolean") {
+        net.syncRotation = source.syncRotation;
+      }
+      if (typeof source.teleportDistance === "number") {
+        net.teleportDistance = source.teleportDistance;
+      }
+    }
+  }
+  {
+    const source = asRecord3(values.networkedPropsValues.get(sourceEntityId));
+    if (source) {
+      let props = world.getComponent(targetEntityId, NetworkedPropsComponent);
+      if (!props) {
+        props = new NetworkedPropsComponent();
+        world.addComponent(targetEntityId, props);
+      }
+      props.values = asRecord3(source.values) ?? {};
+    }
+  }
+  {
+    const source = asRecord3(values.networkSpawnerValues.get(sourceEntityId));
+    if (source) {
+      let spawner = world.getComponent(targetEntityId, NetworkSpawnerComponent);
+      if (!spawner) {
+        spawner = new NetworkSpawnerComponent();
+        world.addComponent(targetEntityId, spawner);
+      }
+      if (typeof source.playerPrefab === "string") {
+        spawner.playerPrefab = source.playerPrefab;
+      }
+      if (typeof source.spawnRadius === "number") {
+        spawner.spawnRadius = source.spawnRadius;
+      }
+    }
+  }
+  {
+    const source = asRecord3(values.ikValues.get(sourceEntityId));
+    if (source) {
+      let ik = world.getComponent(targetEntityId, IKComponent);
+      if (!ik) {
+        ik = new IKComponent();
+        world.addComponent(targetEntityId, ik);
+      }
+      if (typeof source.enabled === "boolean") ik.enabled = source.enabled;
+      if (Array.isArray(source.chains)) {
+        const mapId = /* @__PURE__ */ __name((v) => typeof v === "number" ? idMap.get(v) ?? v : null, "mapId");
+        ik.chains = source.chains.map((raw) => asRecord3(raw)).filter((c) => !!c && typeof c.limb === "string").map(
+          (c) => normalizeIKChain({
+            ...c,
+            limb: c.limb,
+            target: mapId(c.target),
+            pole: mapId(c.pole)
+          })
+        );
+      }
+    }
+  }
+  {
+    const restoreUi = /* @__PURE__ */ __name((map, Ctor, existing) => {
+      const source = asRecord3(map.get(sourceEntityId));
+      if (!source) return;
+      let component = existing;
+      if (!component) {
+        component = new Ctor();
+        world.addComponent(targetEntityId, component);
+      }
+      const target = component;
+      for (const [key, value] of Object.entries(source)) {
+        const current = target[key];
+        if ((typeof value === "string" || typeof value === "number" || typeof value === "boolean") && typeof current === typeof value) {
+          target[key] = value;
+        }
+      }
+    }, "restoreUi");
+    restoreUi(
+      values.uiPanelValues,
+      UIPanelComponent,
+      world.getComponent(targetEntityId, UIPanelComponent)
+    );
+    restoreUi(
+      values.uiTextValues,
+      UITextComponent,
+      world.getComponent(targetEntityId, UITextComponent)
+    );
+    restoreUi(
+      values.uiButtonValues,
+      UIButtonComponent,
+      world.getComponent(targetEntityId, UIButtonComponent)
+    );
+    restoreUi(
+      values.uiToggleValues,
+      UIToggleComponent,
+      world.getComponent(targetEntityId, UIToggleComponent)
+    );
+    restoreUi(
+      values.uiSliderValues,
+      UISliderComponent,
+      world.getComponent(targetEntityId, UISliderComponent)
+    );
+  }
+  {
+    const sourceInteractor = asRecord3(
+      values.xrInteractorValues.get(sourceEntityId)
+    );
+    const interactor = world.getComponent(targetEntityId, XRInteractorComponent);
+    if (sourceInteractor && interactor) {
+      if (typeof sourceInteractor.interactorType === "string") {
+        interactor.interactorType = sourceInteractor.interactorType;
+      }
+      if (typeof sourceInteractor.handPreset === "string") {
+        interactor.handPreset = sourceInteractor.handPreset;
+      }
+      if (typeof sourceInteractor.handColor === "string") {
+        interactor.handColor = sourceInteractor.handColor;
+      }
+      if (typeof sourceInteractor.handOpacity === "number") {
+        interactor.handOpacity = sourceInteractor.handOpacity;
+      }
+      if (typeof sourceInteractor.handEmissiveIntensity === "number") {
+        interactor.handEmissiveIntensity = sourceInteractor.handEmissiveIntensity;
+      }
+      if (typeof sourceInteractor.rayVisibility === "string") {
+        interactor.rayVisibility = sourceInteractor.rayVisibility;
+      } else if (typeof sourceInteractor.showRay === "boolean") {
+        interactor.rayVisibility = sourceInteractor.showRay ? "interacting" : "never";
+      }
+      if (typeof sourceInteractor.rayColor === "string") {
+        interactor.rayColor = sourceInteractor.rayColor;
+      }
+      if (typeof sourceInteractor.rayThickness === "number") {
+        interactor.rayThickness = sourceInteractor.rayThickness;
+      }
+    }
+  }
+  {
+    const sourceSide = asRecord3(
+      values.xrInteractorSideValues.get(sourceEntityId)
+    );
+    if (sourceSide && typeof sourceSide.side === "string") {
+      const existing = world.getComponent(
+        targetEntityId,
+        XRInteractorSideComponent
+      );
+      if (existing) {
+        existing.side = sourceSide.side;
+      } else {
+        world.addComponent(
+          targetEntityId,
+          new XRInteractorSideComponent({
+            side: sourceSide.side
+          })
+        );
+      }
+    }
+  }
+  {
+    const sourceRigOrigin = asRecord3(values.xrRigValues.get(sourceEntityId));
+    const rigForOrigin = world.getComponent(targetEntityId, XRRigComponent);
+    if (sourceRigOrigin && rigForOrigin && typeof sourceRigOrigin.trackingOrigin === "string") {
+      rigForOrigin.trackingOrigin = sourceRigOrigin.trackingOrigin;
+    }
+  }
+  {
+    const imComponent = world.getComponent(targetEntityId, InstancedMeshComponent);
+    if (imComponent && imComponent.instanceEntityIds.length > 0) {
+      imComponent.instanceEntityIds = imComponent.instanceEntityIds.map(
+        (oldId) => idMap.get(oldId) ?? oldId
+      );
+    }
+  }
+  {
+    const slotComponent = world.getComponent(targetEntityId, InstanceSlotComponent);
+    if (slotComponent && slotComponent.groupEntityId !== -1) {
+      slotComponent.groupEntityId = idMap.get(slotComponent.groupEntityId) ?? slotComponent.groupEntityId;
+    }
+  }
+}
+__name(restorePostCreateComponents, "restorePostCreateComponents");
+
+// core/hydration/animation.ts
+function readAnimationClipName(value) {
+  if (typeof value === "string") {
+    return value;
+  }
+  const record = asRecord3(value);
+  if (!record) {
+    return null;
+  }
+  if (typeof record.name === "string") {
+    return record.name;
+  }
+  return null;
+}
+__name(readAnimationClipName, "readAnimationClipName");
+function readAnimationStates(value) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  const states = [];
+  for (const entry of value) {
+    const state = asRecord3(entry);
+    if (!state) {
+      continue;
+    }
+    const name = typeof state.name === "string" ? state.name : null;
+    const clip = readAnimationClipName(state.clip);
+    if (!name || !clip) {
+      continue;
+    }
+    states.push({
+      name,
+      clip,
+      clipId: typeof state.clipId === "string" ? state.clipId : void 0,
+      loop: typeof state.loop === "boolean" ? state.loop : false
+    });
+  }
+  return states;
+}
+__name(readAnimationStates, "readAnimationStates");
+function readAnimationClipSources(value) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const sources = [];
+  for (const entry of value) {
+    if (typeof entry !== "string") {
+      continue;
+    }
+    const trimmed = entry.trim();
+    if (!trimmed || seen.has(trimmed)) {
+      continue;
+    }
+    seen.add(trimmed);
+    sources.push(trimmed);
+  }
+  return sources;
+}
+__name(readAnimationClipSources, "readAnimationClipSources");
+function toAnimationOptions(sourceAnimation) {
+  const paused = readBoolean(sourceAnimation.paused);
+  const reverse = readBoolean(sourceAnimation.reverse);
+  const timeScale = readNumber(sourceAnimation.timeScale);
+  const crossFadeDuration = readNumber(sourceAnimation.crossFadeDuration);
+  const states = readAnimationStates(sourceAnimation.states);
+  const externalClipSources = readAnimationClipSources(
+    sourceAnimation.externalClipSources
+  );
+  const activeStateName = typeof sourceAnimation.activeStateName === "string" ? sourceAnimation.activeStateName : typeof sourceAnimation.activeState === "string" ? sourceAnimation.activeState : typeof sourceAnimation.active?.name === "string" ? sourceAnimation.active.name ?? null : null;
+  return {
+    paused,
+    reverse,
+    timeScale,
+    crossFadeDuration,
+    states,
+    externalClipSources,
+    activeState: activeStateName
+  };
+}
+__name(toAnimationOptions, "toAnimationOptions");
+function restoreAnimationComponent(world, objectManagementSystem, targetEntityId, sourceAnimation) {
+  const options = toAnimationOptions(sourceAnimation);
+  let animation = world.getComponent(targetEntityId, AnimationComponent);
+  if (!animation) {
+    objectManagementSystem.createComponentNow(
+      "animation",
+      world,
+      targetEntityId,
+      options
+    );
+    animation = world.getComponent(targetEntityId, AnimationComponent);
+  }
+  if (!animation) {
+    return;
+  }
+  const availableClips = Array.isArray(sourceAnimation.availableClips) ? sourceAnimation.availableClips.filter(
+    (clip) => typeof clip === "string" && clip.length > 0
+  ) : [];
+  if (availableClips.length > 0) {
+    animation.availableClips = [...availableClips];
+  }
+  if (Array.isArray(options.externalClipSources)) {
+    animation.setExternalClipSources(options.externalClipSources);
+  }
+  const states = options.states ?? [];
+  const hasClips = Array.isArray(animation.clips) && animation.clips.length > 0;
+  if (!hasClips) {
+    animation.__pendingHydratedOptions = options;
+    if (typeof options.reverse === "boolean") {
+      animation.reverse = options.reverse;
+    }
+    if (typeof options.timeScale === "number") {
+      animation.timeScale = options.timeScale;
+    }
+    if (typeof options.crossFadeDuration === "number") {
+      animation.crossFadeDuration = options.crossFadeDuration;
+    }
+    if (typeof options.paused === "boolean") {
+      animation.paused = options.paused;
+    }
+    return;
+  }
+  if (states.length > 0) {
+    animation.setStates(states);
+  }
+  if (typeof options.reverse === "boolean") {
+    animation.reverse = options.reverse;
+  }
+  if (typeof options.timeScale === "number") {
+    animation.timeScale = options.timeScale;
+  }
+  if (typeof options.crossFadeDuration === "number") {
+    animation.crossFadeDuration = options.crossFadeDuration;
+  }
+  if (typeof options.activeState === "string" && options.activeState.length > 0) {
+    animation.setActiveState(options.activeState, !options.paused);
+  }
+  if (typeof options.paused === "boolean") {
+    if (options.paused) {
+      animation.pauseState();
+    } else if (typeof options.activeState === "string" && options.activeState.length > 0) {
+      animation.playState(options.activeState);
+    }
+  }
+}
+__name(restoreAnimationComponent, "restoreAnimationComponent");
+
+// core/hydration/restoreComponentState.ts
+function readEnvironmentState(value) {
+  const record = asRecord3(value);
+  if (!record) {
+    return null;
+  }
+  const nestedValues = asRecord3(record.values);
+  if (nestedValues) {
+    return nestedValues;
+  }
+  return record;
+}
+__name(readEnvironmentState, "readEnvironmentState");
+function readPostprocessingState(value) {
+  const record = asRecord3(value);
+  if (!record) {
+    return null;
+  }
+  const nestedValues = asRecord3(record.values);
+  if (nestedValues) {
+    return nestedValues;
+  }
+  return record;
+}
+__name(readPostprocessingState, "readPostprocessingState");
+function restoreComponentState(world, objectManagementSystem, targetEntityId, sourceEntityId, entityType, values) {
+  const sourceName = readString(values.nameValues.get(sourceEntityId));
+  if (sourceName !== null) {
+    const nameComponent = world.getComponent(targetEntityId, Name);
+    if (nameComponent) {
+      nameComponent.value = sourceName;
+    }
+  }
+  const sourceObject3DRef = asRecord3(values.object3DRefValues.get(sourceEntityId));
+  if (sourceObject3DRef) {
+    const object3DRefComponent = world.getComponent(targetEntityId, Object3DRef);
+    const visibility = readBoolean(sourceObject3DRef.visibility);
+    if (object3DRefComponent && typeof visibility === "boolean") {
+      object3DRefComponent.visibility = visibility;
+    }
+  }
+  const sourceTransform = readTransform(values.transformValues.get(sourceEntityId));
+  if (sourceTransform) {
+    const transformComponent = world.getComponent(targetEntityId, TransformComponent);
+    if (transformComponent) {
+      if (typeof sourceTransform.position?.x === "number") {
+        transformComponent.position.x = sourceTransform.position.x;
+      }
+      if (typeof sourceTransform.position?.y === "number") {
+        transformComponent.position.y = sourceTransform.position.y;
+      }
+      if (typeof sourceTransform.position?.z === "number") {
+        transformComponent.position.z = sourceTransform.position.z;
+      }
+      if (typeof sourceTransform.rotation?.x === "number") {
+        transformComponent.rotation.x = sourceTransform.rotation.x;
+      }
+      if (typeof sourceTransform.rotation?.y === "number") {
+        transformComponent.rotation.y = sourceTransform.rotation.y;
+      }
+      if (typeof sourceTransform.rotation?.z === "number") {
+        transformComponent.rotation.z = sourceTransform.rotation.z;
+      }
+      if (typeof sourceTransform.scale?.x === "number") {
+        transformComponent.scale.x = sourceTransform.scale.x;
+      }
+      if (typeof sourceTransform.scale?.y === "number") {
+        transformComponent.scale.y = sourceTransform.scale.y;
+      }
+      if (typeof sourceTransform.scale?.z === "number") {
+        transformComponent.scale.z = sourceTransform.scale.z;
+      }
+    }
+  }
+  const sourceModel = asRecord3(values.modelValues.get(sourceEntityId));
+  if (sourceModel) {
+    const modelComponent = world.getComponent(targetEntityId, ModelComponent);
+    if (modelComponent && typeof sourceModel.path === "string") {
+      modelComponent.path = sourceModel.path;
+    }
+  }
+  const sourceImage = asRecord3(values.imageValues.get(sourceEntityId));
+  if (sourceImage) {
+    const imageComponent = world.getComponent(targetEntityId, ImageComponent);
+    if (imageComponent) {
+      if (typeof sourceImage.path === "string") {
+        imageComponent.path = sourceImage.path;
+      }
+      const width = readNumber(sourceImage.width);
+      if (typeof width === "number") {
+        imageComponent.width = width;
+      }
+      const height = readNumber(sourceImage.height);
+      if (typeof height === "number") {
+        imageComponent.height = height;
+      }
+    }
+  }
+  const sourceSprite = asRecord3(values.spriteValues.get(sourceEntityId));
+  if (sourceSprite) {
+    const spriteComponent = world.getComponent(targetEntityId, SpriteComponent);
+    if (spriteComponent) {
+      if (typeof sourceSprite.path === "string") {
+        spriteComponent.path = sourceSprite.path;
+      }
+      const width = readNumber(sourceSprite.width);
+      if (typeof width === "number") {
+        spriteComponent.width = width;
+      }
+      const height = readNumber(sourceSprite.height);
+      if (typeof height === "number") {
+        spriteComponent.height = height;
+      }
+    }
+  }
+  const sourceVideo = asRecord3(values.videoValues.get(sourceEntityId));
+  if (sourceVideo) {
+    const videoComponent = world.getComponent(targetEntityId, VideoComponent);
+    if (videoComponent) {
+      if (typeof sourceVideo.path === "string") {
+        videoComponent.path = sourceVideo.path;
+      }
+      const videoOptions = asRecord3(sourceVideo.options);
+      if (videoOptions) {
+        videoComponent.options = {
+          ...videoComponent.options,
+          ...videoOptions
+        };
+      }
+    }
+  }
+  const sourceAudio = asRecord3(values.audioValues.get(sourceEntityId));
+  if (sourceAudio && entityType === "audio") {
+    const audioComponent = world.getComponent(targetEntityId, AudioComponent);
+    if (audioComponent) {
+      if (typeof sourceAudio.path === "string") {
+        audioComponent.path = sourceAudio.path;
+      }
+      const audioOptions = asRecord3(sourceAudio.options);
+      if (audioOptions) {
+        audioComponent.options = {
+          ...audioComponent.options,
+          ...audioOptions
+        };
+      }
+    }
+  }
+  const sourceCamera = asRecord3(values.cameraValues.get(sourceEntityId));
+  if (sourceCamera) {
+    const cameraComponent = world.getComponent(targetEntityId, CameraComponent);
+    if (cameraComponent) {
+      if (sourceCamera.projection === "orthographic" || sourceCamera.projection === "perspective") {
+        cameraComponent.projection = sourceCamera.projection;
+      }
+      if (sourceCamera.type === "3d" || sourceCamera.type === "ar") {
+        cameraComponent.type = sourceCamera.type;
+      }
+      if (typeof sourceCamera.isDefault === "boolean") {
+        cameraComponent.isDefault = sourceCamera.isDefault;
+      }
+      const fov = readNumber(sourceCamera.fov);
+      if (typeof fov === "number") {
+        cameraComponent.fov = fov;
+      }
+      const near = readNumber(sourceCamera.near);
+      if (typeof near === "number") {
+        cameraComponent.near = near;
+      }
+      const far = readNumber(sourceCamera.far);
+      if (typeof far === "number") {
+        cameraComponent.far = far;
+      }
+      const left = readNumber(sourceCamera.left);
+      if (typeof left === "number") {
+        cameraComponent.left = left;
+      }
+      const right = readNumber(sourceCamera.right);
+      if (typeof right === "number") {
+        cameraComponent.right = right;
+      }
+      const top = readNumber(sourceCamera.top);
+      if (typeof top === "number") {
+        cameraComponent.top = top;
+      }
+      const bottom = readNumber(sourceCamera.bottom);
+      if (typeof bottom === "number") {
+        cameraComponent.bottom = bottom;
+      }
+      const zoom = readNumber(sourceCamera.zoom);
+      if (typeof zoom === "number") {
+        cameraComponent.zoom = zoom;
+      }
+    }
+  }
+  const sourceEnvironment = readEnvironmentState(
+    values.environmentValues.get(sourceEntityId)
+  );
+  if (sourceEnvironment) {
+    let environmentComponent = world.getComponent(targetEntityId, Environment);
+    if (!environmentComponent) {
+      objectManagementSystem.createComponentNow(
+        "environment",
+        world,
+        targetEntityId,
+        sourceEnvironment
+      );
+      environmentComponent = world.getComponent(targetEntityId, Environment);
+    }
+    if (environmentComponent) {
+      environmentComponent.values = new Environment({
+        ...environmentComponent.values,
+        ...sourceEnvironment
+      }).values;
+    }
+  }
+  const sourcePostprocessing = readPostprocessingState(
+    values.postprocessingValues.get(sourceEntityId)
+  );
+  if (sourcePostprocessing) {
+    let postprocessingComponent = world.getComponent(targetEntityId, Postprocessing);
+    if (!postprocessingComponent) {
+      objectManagementSystem.createComponentNow(
+        "postprocessing",
+        world,
+        targetEntityId,
+        sourcePostprocessing
+      );
+      postprocessingComponent = world.getComponent(targetEntityId, Postprocessing);
+    }
+    if (postprocessingComponent) {
+      postprocessingComponent.values = new Postprocessing({
+        ...postprocessingComponent.values,
+        ...sourcePostprocessing
+      }).values;
+    }
+  }
+  const sourceImageTarget = asRecord3(values.imageTargetValues.get(sourceEntityId));
+  if (sourceImageTarget && entityType === "imageTarget") {
+    const imageTargetComponent = world.getComponent(targetEntityId, ImageTarget);
+    if (imageTargetComponent) {
+      imageTargetComponent.targets = Array.isArray(sourceImageTarget.targets) ? sourceImageTarget.targets : [];
+      imageTargetComponent.compiledTargetUrl = typeof sourceImageTarget.compiledTargetUrl === "string" ? sourceImageTarget.compiledTargetUrl : void 0;
+      imageTargetComponent.compiledTargetDir = typeof sourceImageTarget.compiledTargetDir === "string" ? sourceImageTarget.compiledTargetDir : void 0;
+    }
+  }
+  const sourceLight = asRecord3(values.lightValues.get(sourceEntityId));
+  if (sourceLight) {
+    const lightComponent = world.getComponent(targetEntityId, LightComponent);
+    const sourceValues = asRecord3(sourceLight.values);
+    if (lightComponent && sourceValues) {
+      lightComponent.values = {
+        ...lightComponent.values,
+        ...sourceValues
+      };
+    }
+  }
+  const sourceMaterial = asRecord3(values.materialValues.get(sourceEntityId));
+  if (sourceMaterial) {
+    const materialComponent = world.getComponent(targetEntityId, MaterialComponent);
+    const sourceValues = sourceMaterial.values;
+    if (materialComponent && Array.isArray(sourceValues)) {
+      materialComponent.values = sourceValues;
+    }
+    const sourceAssetRefs = sourceMaterial.assetRefs;
+    if (materialComponent && Array.isArray(sourceAssetRefs)) {
+      materialComponent.assetRefs = sourceAssetRefs;
+    }
+  }
+  const sourceMeshGeometry = asRecord3(values.meshGeometryValues.get(sourceEntityId));
+  if (sourceMeshGeometry) {
+    const meshGeometryComponent = world.getComponent(
+      targetEntityId,
+      MeshGeometryComponent
+    );
+    if (meshGeometryComponent) {
+      const parameters = asRecord3(sourceMeshGeometry.parameters);
+      if (parameters) {
+        meshGeometryComponent.parameters = parameters;
+      }
+      if (typeof sourceMeshGeometry.modelName === "string") {
+        meshGeometryComponent.modelName = sourceMeshGeometry.modelName;
+      }
+      if (typeof sourceMeshGeometry.castShadow === "boolean") {
+        meshGeometryComponent.castShadow = sourceMeshGeometry.castShadow;
+      }
+      if (typeof sourceMeshGeometry.receiveShadow === "boolean") {
+        meshGeometryComponent.receiveShadow = sourceMeshGeometry.receiveShadow;
+      }
+    }
+  }
+  const sourceSelectable = asRecord3(values.selectableValues.get(sourceEntityId));
+  if (sourceSelectable) {
+    const enabled = readBoolean(sourceSelectable.enabled);
+    let selectable = world.getComponent(targetEntityId, Selectable);
+    if (!selectable) {
+      objectManagementSystem.createComponentNow(
+        "selectable",
+        world,
+        targetEntityId,
+        enabled ?? true
+      );
+      selectable = world.getComponent(targetEntityId, Selectable);
+    }
+    if (selectable && typeof enabled === "boolean") {
+      selectable.enabled = enabled;
+    }
+  }
+  const sourcePhysics = asRecord3(values.physicsValues.get(sourceEntityId));
+  if (sourcePhysics) {
+    const physicsValues = asRecord3(sourcePhysics.values) ?? sourcePhysics;
+    let physics = world.getComponent(targetEntityId, PhysicsComponent);
+    if (!physics) {
+      objectManagementSystem.createComponentNow(
+        "physics",
+        world,
+        targetEntityId,
+        physicsValues
+      );
+      physics = world.getComponent(targetEntityId, PhysicsComponent);
+    }
+    if (physics) {
+      physics.setValues({
+        rigidbody: asRecord3(physicsValues.rigidbody) ?? {},
+        collider: asRecord3(physicsValues.collider) ?? {}
+      });
+    }
+  }
+  const sourceAnimation = asRecord3(values.animationValues.get(sourceEntityId));
+  if (sourceAnimation) {
+    restoreAnimationComponent(
+      world,
+      objectManagementSystem,
+      targetEntityId,
+      sourceAnimation
+    );
+  }
+  const sourceInstancedMesh = asRecord3(values.instancedMeshValues.get(sourceEntityId));
+  if (sourceInstancedMesh) {
+    const imComponent = world.getComponent(targetEntityId, InstancedMeshComponent);
+    if (imComponent) {
+      if (typeof sourceInstancedMesh.meshKind === "string") {
+        imComponent.meshKind = sourceInstancedMesh.meshKind;
+      }
+      if (typeof sourceInstancedMesh.modelPath === "string") {
+        imComponent.modelPath = sourceInstancedMesh.modelPath;
+      }
+      const parameters = asRecord3(sourceInstancedMesh.meshParameters);
+      if (parameters) {
+        imComponent.meshParameters = parameters;
+      }
+      if (typeof sourceInstancedMesh.castShadow === "boolean") {
+        imComponent.castShadow = sourceInstancedMesh.castShadow;
+      }
+      if (typeof sourceInstancedMesh.receiveShadow === "boolean") {
+        imComponent.receiveShadow = sourceInstancedMesh.receiveShadow;
+      }
+      if (Array.isArray(sourceInstancedMesh.instanceEntityIds)) {
+        imComponent.instanceEntityIds = sourceInstancedMesh.instanceEntityIds;
+      }
+      imComponent.instancedMesh = null;
+    }
+  }
+  const sourceInstanceSlot = asRecord3(values.instanceSlotValues.get(sourceEntityId));
+  if (sourceInstanceSlot) {
+    const slotComponent = world.getComponent(targetEntityId, InstanceSlotComponent);
+    if (slotComponent) {
+      if (typeof sourceInstanceSlot.slotIndex === "number") {
+        slotComponent.slotIndex = sourceInstanceSlot.slotIndex;
+      }
+    }
+  }
+  const sourcePrefabNode = asRecord3(values.prefabNodeValues.get(sourceEntityId));
+  if (sourcePrefabNode && typeof sourcePrefabNode.nodeId === "string") {
+    if (!world.getComponent(targetEntityId, PrefabNode)) {
+      world.addComponent(targetEntityId, new PrefabNode(sourcePrefabNode.nodeId));
+    }
+  }
+  const sourcePrefabInstance = asRecord3(
+    values.prefabInstanceValues.get(sourceEntityId)
+  );
+  if (sourcePrefabInstance && typeof sourcePrefabInstance.url === "string") {
+    if (!world.getComponent(targetEntityId, PrefabInstance)) {
+      const overrides = Array.isArray(sourcePrefabInstance.overrides) ? sourcePrefabInstance.overrides.filter(
+        (entry) => typeof entry === "string"
+      ) : [];
+      world.addComponent(
+        targetEntityId,
+        new PrefabInstance(
+          sourcePrefabInstance.url,
+          overrides,
+          // Preserve the placement identity; the constructor generates a
+          // fresh one for legacy snapshots that predate instanceId.
+          typeof sourcePrefabInstance.instanceId === "string" && sourcePrefabInstance.instanceId.length > 0 ? sourcePrefabInstance.instanceId : void 0
+        )
+      );
+    }
+  }
+}
+__name(restoreComponentState, "restoreComponentState");
+
+// core/hydration/types.ts
+var HYDRATABLE_ENTITY_KINDS = /* @__PURE__ */ new Set([
+  "cube",
+  "sphere",
+  "plane",
+  "capsule",
+  "cylinder",
+  "empty",
+  "model",
+  "image",
+  "imageTarget",
+  "sprite",
+  "audio",
+  "camera",
+  "video",
+  "ambientLight",
+  "directionalLight",
+  "pointLight",
+  "spotLight",
+  "areaLight",
+  "instancedMesh",
+  "instanceSlot",
+  "scriptObject",
+  "xrRig",
+  "xrInteractor",
+  "teleportArea",
+  "uiPanel",
+  "uiText",
+  "uiButton",
+  "uiToggle",
+  "uiSlider"
+]);
+
+// core/hydration/hydrateWorld.ts
+function buildEntityCreationPayload(sourceEntityId, kind, componentValues) {
+  const payload = {
+    name: readString(componentValues.nameValues.get(sourceEntityId)) ?? void 0,
+    transform: readTransform(componentValues.transformValues.get(sourceEntityId))
+  };
+  if (kind === "model") {
+    const model = asRecord3(componentValues.modelValues.get(sourceEntityId));
+    if (typeof model?.path === "string") {
+      payload.path = model.path;
+    }
+  }
+  if (kind === "image") {
+    const image = asRecord3(componentValues.imageValues.get(sourceEntityId));
+    if (typeof image?.path === "string") {
+      payload.path = image.path;
+    }
+  }
+  if (kind === "sprite") {
+    const sprite = asRecord3(componentValues.spriteValues.get(sourceEntityId));
+    if (typeof sprite?.path === "string") {
+      payload.path = sprite.path;
+    }
+  }
+  if (kind === "video") {
+    const video = asRecord3(componentValues.videoValues.get(sourceEntityId));
+    if (typeof video?.path === "string") {
+      payload.path = video.path;
+    }
+    const videoOptions = asRecord3(video?.options);
+    if (videoOptions) {
+      payload.options = videoOptions;
+    }
+  }
+  if (kind === "audio") {
+    const audio = asRecord3(componentValues.audioValues.get(sourceEntityId));
+    if (typeof audio?.path === "string") {
+      payload.path = audio.path;
+    }
+    const audioOptions = asRecord3(audio?.options);
+    if (audioOptions) {
+      payload.options = audioOptions;
+    }
+  }
+  if (kind === "camera") {
+    const camera = asRecord3(componentValues.cameraValues.get(sourceEntityId));
+    if (camera) {
+      const projection = camera.projection === "orthographic" || camera.projection === "perspective" ? camera.projection : void 0;
+      const type = camera.type === "3d" || camera.type === "ar" ? camera.type : void 0;
+      payload.options = {
+        isDefault: typeof camera.isDefault === "boolean" ? camera.isDefault : void 0,
+        projection,
+        type,
+        fov: typeof camera.fov === "number" ? camera.fov : void 0,
+        near: typeof camera.near === "number" ? camera.near : void 0,
+        far: typeof camera.far === "number" ? camera.far : void 0,
+        left: typeof camera.left === "number" ? camera.left : void 0,
+        right: typeof camera.right === "number" ? camera.right : void 0,
+        top: typeof camera.top === "number" ? camera.top : void 0,
+        bottom: typeof camera.bottom === "number" ? camera.bottom : void 0,
+        zoom: typeof camera.zoom === "number" ? camera.zoom : void 0
+      };
+    }
+  }
+  if (kind === "imageTarget") {
+    const imageTarget = asRecord3(componentValues.imageTargetValues.get(sourceEntityId));
+    if (imageTarget) {
+      payload.options = {
+        targets: Array.isArray(imageTarget.targets) ? imageTarget.targets : [],
+        compiledTargetUrl: typeof imageTarget.compiledTargetUrl === "string" ? imageTarget.compiledTargetUrl : void 0,
+        compiledTargetDir: typeof imageTarget.compiledTargetDir === "string" ? imageTarget.compiledTargetDir : void 0
+      };
+    }
+  }
+  if (kind === "instancedMesh") {
+    const im = asRecord3(componentValues.instancedMeshValues.get(sourceEntityId));
+    if (im) {
+      payload.options = {
+        meshKind: typeof im.meshKind === "string" ? im.meshKind : "cube",
+        modelPath: typeof im.modelPath === "string" ? im.modelPath : void 0,
+        meshParameters: asRecord3(im.meshParameters) ?? void 0,
+        castShadow: typeof im.castShadow === "boolean" ? im.castShadow : false,
+        receiveShadow: typeof im.receiveShadow === "boolean" ? im.receiveShadow : false,
+        // New format: signal the factory to skip child entity creation.
+        // Old format (instances[]): pass through for migration — factory will
+        // create slot entities from the legacy InstanceTransform array.
+        ...Array.isArray(im.instanceEntityIds) ? { instanceEntityIds: im.instanceEntityIds } : Array.isArray(im.instances) ? { instances: im.instances } : {}
+      };
+    }
+  }
+  if (kind === "instanceSlot") {
+    const slot = asRecord3(componentValues.instanceSlotValues.get(sourceEntityId));
+    if (slot) {
+      payload.options = {
+        groupEntityId: typeof slot.groupEntityId === "number" ? slot.groupEntityId : -1,
+        slotIndex: typeof slot.slotIndex === "number" ? slot.slotIndex : 0
+      };
+    }
+  }
+  if (kind === "scriptObject") {
+    const so = asRecord3(componentValues.scriptObjectValues.get(sourceEntityId));
+    if (so) {
+      payload.options = {
+        scriptUrl: typeof so.scriptUrl === "string" ? so.scriptUrl : null,
+        className: typeof so.className === "string" ? so.className : null,
+        enabled: typeof so.enabled === "boolean" ? so.enabled : true
+      };
+    }
+  }
+  return payload;
+}
+__name(buildEntityCreationPayload, "buildEntityCreationPayload");
+function resolvePrimaryCameraSourceEntityId(snapshot, componentValues, entityTypeValues) {
+  let firstCameraSourceEntityId = null;
+  for (const sourceEntityId of snapshot.entities) {
+    const entityType = readString(entityTypeValues.get(sourceEntityId));
+    if (entityType !== "camera") {
+      continue;
+    }
+    if (firstCameraSourceEntityId === null) {
+      firstCameraSourceEntityId = sourceEntityId;
+    }
+    const cameraValue = asRecord3(componentValues.cameraValues.get(sourceEntityId));
+    if (cameraValue?.isDefault === true) {
+      return sourceEntityId;
+    }
+  }
+  return firstCameraSourceEntityId;
+}
+__name(resolvePrimaryCameraSourceEntityId, "resolvePrimaryCameraSourceEntityId");
+function applyLocalTransformsAfterHierarchyRestore(world, scopeEntityIds) {
+  const transformEntities = scopeEntityIds ? Array.from(scopeEntityIds) : world.query(TransformComponent, Object3DRef);
+  for (const entityId of transformEntities) {
+    const transform = world.getComponent(entityId, TransformComponent);
+    const object = world.getComponent(entityId, Object3DRef)?.object;
+    if (!transform || !object) {
+      continue;
+    }
+    applyTransform(object, transform);
+    object.updateMatrixWorld(true);
+  }
+}
+__name(applyLocalTransformsAfterHierarchyRestore, "applyLocalTransformsAfterHierarchyRestore");
+function hydrateWorldFromSnapshotDetailed(snapshot, world, objectManagementSystem, options) {
+  if (!snapshot || !snapshot.entities.length) {
+    return {
+      restoredCount: 0,
+      selectedEntityId: null,
+      idMap: /* @__PURE__ */ new Map()
+    };
+  }
+  const assignPrimaryCamera = options?.assignPrimaryCamera !== false;
+  const entityTypeValues = readByComponent(snapshot.components, "EntityType");
+  const componentValues = buildComponentValueMaps(snapshot);
+  const primaryCameraSourceEntityId = assignPrimaryCamera ? resolvePrimaryCameraSourceEntityId(
+    snapshot,
+    componentValues,
+    entityTypeValues
+  ) : null;
+  const idMap = /* @__PURE__ */ new Map();
+  for (const sourceEntityId of snapshot.entities) {
+    const entityTypeValue = entityTypeValues.get(sourceEntityId);
+    const entityType = readString(entityTypeValue);
+    if (!entityType || !HYDRATABLE_ENTITY_KINDS.has(entityType)) {
+      continue;
+    }
+    const kind = entityType;
+    const payload = buildEntityCreationPayload(sourceEntityId, kind, componentValues);
+    if (kind === "camera" && sourceEntityId === primaryCameraSourceEntityId) {
+      payload.useWorldCamera = true;
+      const options2 = asRecord3(payload.options);
+      payload.options = {
+        ...options2 ?? {},
+        isDefault: true
+      };
+    }
+    payload.skipDefaultChildren = true;
+    const createdEntityId = objectManagementSystem.createNow(kind, world, payload);
+    idMap.set(sourceEntityId, createdEntityId);
+  }
+  for (const sourceEntityId of snapshot.entities) {
+    const targetEntityId = idMap.get(sourceEntityId);
+    if (targetEntityId === void 0) {
+      continue;
+    }
+    const entityType = readString(entityTypeValues.get(sourceEntityId));
+    restoreComponentState(
+      world,
+      objectManagementSystem,
+      targetEntityId,
+      sourceEntityId,
+      entityType,
+      componentValues
+    );
+    restorePostCreateComponents(
+      world,
+      objectManagementSystem,
+      targetEntityId,
+      sourceEntityId,
+      entityType,
+      componentValues,
+      idMap
+    );
+  }
+  applyParentLinks(snapshot, idMap, objectManagementSystem, world);
+  objectManagementSystem.reconcileSceneFromWorld(world);
+  applyLocalTransformsAfterHierarchyRestore(
+    world,
+    options?.applyTransformsScope === "created" ? idMap.values() : void 0
+  );
+  const selectedEntityId = typeof snapshot.selectedEntityId === "number" ? idMap.get(snapshot.selectedEntityId) ?? null : null;
+  return {
+    restoredCount: idMap.size,
+    selectedEntityId,
+    idMap
+  };
+}
+__name(hydrateWorldFromSnapshotDetailed, "hydrateWorldFromSnapshotDetailed");
+
+// core/prefab/overrides.ts
+var asRecord4 = /* @__PURE__ */ __name((value) => value !== null && typeof value === "object" && !Array.isArray(value) ? value : null, "asRecord");
+function findSnapshotRootEntityIds(snapshot) {
+  const parentBlock = snapshot.components.find(
+    (block) => block.component === "ParentId"
+  );
+  const parentByEntity = /* @__PURE__ */ new Map();
+  for (const entry of parentBlock?.entries ?? []) {
+    parentByEntity.set(entry.entityId, asRecord4(entry.value)?.value ?? null);
+  }
+  return snapshot.entities.filter(
+    (entityId) => typeof parentByEntity.get(entityId) !== "number"
+  );
+}
+__name(findSnapshotRootEntityIds, "findSnapshotRootEntityIds");
+
+// core/prefab/instantiateSubtree.ts
+var INSTANTIATE_EXCLUDED_COMPONENTS = /* @__PURE__ */ new Set([
+  "Environment",
+  "Postprocessing",
+  "SelectionTransformState"
+]);
+function instantiateSubtree(world, objectManagementSystem, snapshot) {
+  const snapshotRootIds = new Set(findSnapshotRootEntityIds(snapshot));
+  const safeSnapshot = {
+    entities: snapshot.entities,
+    components: snapshot.components.filter((block) => !INSTANTIATE_EXCLUDED_COMPONENTS.has(block.component)).map(
+      (block) => block.component === "PrefabInstance" ? {
+        component: block.component,
+        entries: block.entries.filter(
+          (entry) => !snapshotRootIds.has(entry.entityId)
+        )
+      } : block
+    ).filter((block) => block.entries.length > 0)
+  };
+  const result = hydrateWorldFromSnapshotDetailed(
+    safeSnapshot,
+    world,
+    objectManagementSystem,
+    { assignPrimaryCamera: false, applyTransformsScope: "created" }
+  );
+  const rootSourceId = findSnapshotRootEntityIds(safeSnapshot).find(
+    (sourceId) => result.idMap.has(sourceId)
+  );
+  return {
+    rootId: rootSourceId !== void 0 ? result.idMap.get(rootSourceId) ?? null : null,
+    idMap: result.idMap
+  };
+}
+__name(instantiateSubtree, "instantiateSubtree");
+
+// core/prefab/types.ts
+var isRecord = /* @__PURE__ */ __name((value) => value !== null && typeof value === "object" && !Array.isArray(value), "isRecord");
+function parsePrefabAsset(json) {
+  if (!isRecord(json)) {
+    return null;
+  }
+  if (typeof json.version !== "number" || json.version < 1) {
+    return null;
+  }
+  const snapshot = json.snapshot;
+  if (!isRecord(snapshot)) {
+    return null;
+  }
+  const entities = snapshot.entities;
+  const components = snapshot.components;
+  if (!Array.isArray(entities) || !Array.isArray(components)) {
+    return null;
+  }
+  if (!entities.every((id) => typeof id === "number")) {
+    return null;
+  }
+  if (!components.every(
+    (block) => isRecord(block) && typeof block.component === "string" && Array.isArray(block.entries)
+  )) {
+    return null;
+  }
+  return {
+    version: json.version,
+    type: json.type === "scene" ? "scene" : "prefab",
+    name: typeof json.name === "string" ? json.name : void 0,
+    snapshot
+  };
+}
+__name(parsePrefabAsset, "parsePrefabAsset");
+var resolvePrefabAssetUrl = /* @__PURE__ */ __name((url) => url, "resolvePrefabAssetUrl");
+var resolveUrl = resolvePrefabAssetUrl;
+function transformStringsDeep(value, fn) {
+  if (typeof value === "string") {
+    return fn(value);
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => transformStringsDeep(item, fn));
+  }
+  if (value !== null && typeof value === "object") {
+    const result = {};
+    for (const [key, item] of Object.entries(value)) {
+      result[key] = transformStringsDeep(item, fn);
+    }
+    return result;
+  }
+  return value;
+}
+__name(transformStringsDeep, "transformStringsDeep");
+var prefabCache = /* @__PURE__ */ new Map();
+function loadPrefab(url) {
+  const cached = prefabCache.get(url);
+  if (cached) {
+    return cached;
+  }
+  const pending = (async () => {
+    const response = await fetch(resolveUrl(url));
+    if (!response.ok) {
+      throw new Error(`Failed to fetch prefab "${url}" (${response.status})`);
+    }
+    const json = await response.json();
+    const parsed = parsePrefabAsset(json);
+    if (!parsed) {
+      throw new Error(`Invalid prefab file at "${url}"`);
+    }
+    return {
+      ...parsed,
+      snapshot: transformStringsDeep(
+        parsed.snapshot,
+        resolveUrl
+      )
+    };
+  })();
+  prefabCache.set(url, pending);
+  pending.catch(() => {
+    if (prefabCache.get(url) === pending) {
+      prefabCache.delete(url);
+    }
+  });
+  return pending;
+}
+__name(loadPrefab, "loadPrefab");
+function resolveSource(source) {
+  if (typeof source === "string") {
+    return { url: source, asset: loadPrefab(source) };
+  }
+  if ("path" in source && typeof source.path === "string") {
+    return { url: source.path, asset: loadPrefab(source.path) };
+  }
+  const asset = source;
+  return { url: asset.name ?? "", asset };
+}
+__name(resolveSource, "resolveSource");
+async function spawnPrefab(world, source, options) {
+  const { url, asset } = resolveSource(source);
+  const prefab = await asset;
+  const objectManagementSystem = world.getObjectManagementSystem();
+  const { rootId } = instantiateSubtree(
+    world,
+    objectManagementSystem,
+    prefab.snapshot
+  );
+  if (rootId === null) {
+    throw new Error(
+      `Prefab "${url || prefab.name || "unknown"}" contained no spawnable entities`
+    );
+  }
+  if (!world.getComponent(rootId, PrefabInstance)) {
+    world.addComponent(rootId, new PrefabInstance(url, []));
+  }
+  if (options?.parentId !== void 0 && options.parentId !== null) {
+    objectManagementSystem.setParent(world, rootId, options.parentId, {
+      preserveWorldTransform: false
+    });
+  }
+  const transform = world.getComponent(rootId, TransformComponent);
+  if (transform && (options?.position || options?.rotation || options?.scale)) {
+    const write = /* @__PURE__ */ __name((target, src) => {
+      if (!src) return;
+      if (typeof src.x === "number") target.x = src.x;
+      if (typeof src.y === "number") target.y = src.y;
+      if (typeof src.z === "number") target.z = src.z;
+    }, "write");
+    write(transform.position, options.position);
+    write(transform.rotation, options.rotation);
+    write(transform.scale, options.scale);
+    const object = world.getComponent(rootId, Object3DRef)?.object;
+    if (object) {
+      applyTransform(object, transform);
+      object.updateMatrixWorld(true);
+    }
+  }
+  return rootId;
+}
+__name(spawnPrefab, "spawnPrefab");
+function despawnPrefab(world, rootId, dispose = true) {
+  const objectManagementSystem = world.getObjectManagementSystem();
+  const subtree = collectEntitySubtree(world, [rootId]).reverse();
+  let removed = 0;
+  for (const entityId of subtree) {
+    if (objectManagementSystem.deleteEntity(world, entityId, dispose)) {
+      removed += 1;
+    }
+  }
+  return removed;
+}
+__name(despawnPrefab, "despawnPrefab");
+var _Behaviour = class _Behaviour {
+  /**
+   * Engine-managed constructor. Hosts (`ScriptBehaviourSystem`) instantiate
+   * subclasses with the owning world, the entity id, and the script's `data`
+   * payload. User code should not call this directly.
+   *
+   * @param world - The owning ECS world.
+   * @param entityId - The entity this script is bound to.
+   * @param component - The `ScriptComponent.data` payload, or any object that
+   *   should be exposed to the script as `this.data`.
+   */
+  constructor(world, entityId, component) {
+    /**
+     * Inspector-bound payload from the entity's `ScriptComponent`. Override the
+     * type on subclasses with `declare data: MyDataShape` to get type safety
+     * inside hooks. Saved with the project so values persist across reloads.
+     */
+    this.data = {};
+    /**
+     * Seconds elapsed since the last frame. Set by the engine before each
+     * {@link Behaviour.onUpdate}.
+     */
+    this.deltaTime = 0;
+    this.world = world;
+    this.entityId = entityId;
+    if (component) this.data = component;
+    this.entity = this.getEntity();
+    this.threeRef = this.getComponent(Object3DRef);
+    this.transform = this.getComponent(TransformComponent);
+  }
+  /**
+   * Engine-managed per-frame entry point. Refreshes {@link Behaviour.deltaTime}
+   * and delegates to {@link Behaviour.onUpdate}.
+   *
+   * @remarks Do **not** override this method — override
+   * {@link Behaviour.onUpdate} instead.
+   *
+   * @param world - The owning world (may differ from the constructor world
+   *   after hot reload).
+   * @param deltaTime - Seconds since the last frame.
+   */
+  update(world, deltaTime) {
+    this.deltaTime = deltaTime;
+    this.world = world;
+    this.onUpdate();
+  }
+  /**
+   * Optional cleanup hook invoked when the script is detached or the entity
+   * is destroyed. Override to release timers, listeners, or other resources.
+   *
+   * @param world - The owning world at disposal time.
+   */
+  dispose(world) {
+  }
+  /**
+   * Instantiate a prefab asset into the world at runtime.
+   *
+   * `source` is typically an `AssetInput` field from this script's `data`
+   * (drag a `.prefab` from the asset browser onto the field in the editor),
+   * a URL string, or a pre-loaded `PrefabAsset`. Resolves with the new root
+   * entity id.
+   *
+   * ```ts
+   * data = { enemyPrefab: { path: "", type: "prefab" } };
+   * async onUpdate() {
+   *   if (shouldSpawn) {
+   *     const id = await this.spawnPrefab(this.data.enemyPrefab, {
+   *       position: { x: 0, y: 0, z: -5 },
+   *     });
+   *   }
+   * }
+   * ```
+   */
+  spawnPrefab(source, options) {
+    return spawnPrefab(this.world, source, options);
+  }
+  /**
+   * The shared world, or `null` in a single-player run, so a script can work
+   * both ways:
+   *
+   * ```ts
+   * if (this.network && !this.network.isOwner) return; // someone else moves this
+   * ```
+   */
+  get network() {
+    return this.world.getNetwork()?.handleFor(this.entityId) ?? null;
+  }
+  /** Someone joined the room. `playerId` is their session id. */
+  onPlayerJoin(_playerId) {
+  }
+  /** Someone left the room. */
+  onPlayerLeave(_playerId) {
+  }
+  /** A shared value on this entity changed. */
+  onNetworkProp(_key, _value) {
+  }
+  /**
+   * Load a `.soundbank.json` asset so {@link Behaviour.playSlot} can play it.
+   * `source` is an asset path or an `AssetInput` field.
+   */
+  loadSoundBank(source) {
+    return this.world.getAudioSystem()?.loadSoundBank(source) ?? Promise.resolve();
+  }
+  /**
+   * Play a named sound from a loaded bank, as a random take. Returns whether it
+   * sounded: its chance, cooldown or priority may keep it quiet.
+   *
+   * ```ts
+   * this.playSlot("hit", { position: this.transform.position });
+   * ```
+   */
+  playSlot(id, options) {
+    return this.world.getAudioSystem()?.playSlot(id, options) ?? false;
+  }
+  /**
+   * Remove a spawned prefab instance (the root entity and all descendants).
+   * Returns the number of entities removed.
+   */
+  despawn(rootEntityId) {
+    return despawnPrefab(this.world, rootEntityId);
+  }
+  /**
+   * Returns the entity's world-space position as a new `THREE.Vector3`, or
+   * `null` if the entity has no scene presence.
+   */
+  getWorldPosition() {
+    if (!this.threeRef) {
+      return null;
+    }
+    const position = new THREE5__namespace.Vector3();
+    this.threeRef.object.getWorldPosition(position);
+    return position;
+  }
+  /**
+   * Returns the entity's forward direction in world space (the +Z axis of its
+   * world matrix), or `null` if the entity has no scene presence.
+   */
+  getWorldDirection() {
+    if (!this.threeRef) {
+      return null;
+    }
+    const target = new THREE5__namespace.Vector3();
+    this.threeRef.object.getWorldDirection(target);
+    return target;
+  }
+  /**
+   * Returns a unit vector pointing from this entity toward the given world
+   * position, or `null` if the entity has no scene presence.
+   *
+   * @param targetPosition - Destination point in world space.
+   */
+  directionTo(targetPosition) {
+    const currentPosition = this.getWorldPosition();
+    if (!currentPosition) {
+      return null;
+    }
+    return targetPosition.clone().sub(currentPosition).normalize();
+  }
+  /**
+   * Returns the world-space distance from this entity to the given position,
+   * or `null` if the entity has no scene presence.
+   *
+   * @param targetPosition - Destination point in world space.
+   */
+  distanceTo(targetPosition) {
+    const currentPosition = this.getWorldPosition();
+    if (!currentPosition) {
+      return null;
+    }
+    return currentPosition.distanceTo(targetPosition);
+  }
+  /**
+   * Linearly interpolates the entity's position toward `targetPosition` and
+   * writes the result back through {@link TransformComponent}. No-op if the
+   * entity has no scene presence.
+   *
+   * @param targetPosition - Destination point in world space.
+   * @param alpha - Interpolation factor in [0, 1]. Multiply by `deltaTime`
+   *   for frame-rate-independent smoothing.
+   */
+  lerpTo(targetPosition, alpha) {
+    if (!this.threeRef) {
+      return;
+    }
+    const currentPosition = this.getWorldPosition();
+    if (!currentPosition) {
+      return;
+    }
+    const newPosition = currentPosition.lerp(targetPosition, alpha);
+    this.transform.setPosition(newPosition);
+  }
+  /**
+   * Spherically interpolates the entity's rotation toward `targetRotation`
+   * and writes the result back through {@link TransformComponent}. No-op if
+   * the entity has no scene presence.
+   *
+   * @param targetRotation - Destination orientation as a quaternion.
+   * @param alpha - Interpolation factor in [0, 1].
+   */
+  slerpTo(targetRotation, alpha) {
+    if (!this.threeRef) {
+      return;
+    }
+    const rotation = new THREE5__namespace.Quaternion();
+    this.threeRef.object.getWorldQuaternion(rotation);
+    rotation.slerp(targetRotation, alpha);
+    this.transform.setRotation(rotation);
+  }
+  /**
+   * Rotates the entity to face `targetPosition` in world space and writes the
+   * resulting orientation back through {@link TransformComponent}. No-op if
+   * the entity has no scene presence.
+   *
+   * @param targetPosition - Point in world space to face.
+   */
+  lookAt(targetPosition) {
+    if (!this.threeRef) {
+      return;
+    }
+    const clone = this.threeRef.object.clone();
+    const rotation = new THREE5__namespace.Quaternion();
+    clone.lookAt(targetPosition);
+    clone.getWorldQuaternion(rotation);
+    this.transform.setRotation(rotation);
+  }
+  /** Returns every component currently attached to this entity. */
+  getComponents() {
+    return this.world.getEntityById(this.entityId)?.components ?? [];
+  }
+  /**
+   * Returns the entity's component of the given class, or `null` if it has
+   * no such component.
+   *
+   * @typeParam T - Concrete component type.
+   * @param componentClass - Component class constructor to look up.
+   *
+   * @example
+   * ```ts
+   * const mesh = this.getComponent(MeshComponent);
+   * if (mesh) console.log(mesh.geometryRef);
+   * ```
+   */
+  getComponent(componentClass) {
+    return this.world.getComponent(this.entityId, componentClass) ?? null;
+  }
+  /**
+   * Returns the latest {@link WorldEntityView} snapshot for this entity, or
+   * `null` if it was destroyed.
+   */
+  getEntity() {
+    return this.world.getEntityById(this.entityId);
+  }
+  /**
+   * Resolves the entity's parent from the {@link ParentId} component, if any.
+   *
+   * @returns A {@link ParentLookup} with the parent component reference and
+   *   the parent entity view (or `null` if the entity is at the root).
+   */
+  getParent() {
+    const parentIdComponent = this.getComponent(ParentId);
+    const parentEntityId = parentIdComponent?.value ?? null;
+    if (parentEntityId === null) {
+      return {
+        parentIdComponent,
+        parent: null
+      };
+    }
+    return {
+      parentIdComponent,
+      parent: this.world.getEntityById(parentEntityId)
+    };
+  }
+  /**
+   * Returns every direct child entity of this one (entities whose
+   * {@link ParentId} matches `entityId`).
+   */
+  getChildren() {
+    return this.world.getAllEntities().filter((entity) => {
+      const parentIdComponent = entity.components.find(
+        (component) => component instanceof ParentId
+      );
+      return parentIdComponent?.value === this.entityId;
+    });
+  }
+  /**
+   * Called once before the first {@link Behaviour.onUpdate}. Override to
+   * default and validate {@link Behaviour.data}, cache references, or set
+   * initial state. Runs at preview/runtime only — never in the editor.
+   */
+  init() {
+  }
+  /**
+   * Called every frame while the script is enabled. Override with the
+   * script's main per-frame logic. Runs at preview/runtime only — never in the
+   * editor (use {@link ScriptObject} for editor-visible visuals).
+   */
+  onUpdate() {
+  }
+  /** Called when the editor selects this entity. Optional UX hook. */
+  onSelect() {
+  }
+  /** Called when the editor deselects this entity. Optional UX hook. */
+  onDeselect() {
+  }
+  /**
+   * Called when an image-tracking target this entity depends on becomes
+   * visible. Optional AR hook.
+   *
+   * @param target - The newly-visible target entity view.
+   */
+  onTargetFound(target) {
+  }
+  /**
+   * Called when an image-tracking target this entity depends on is lost.
+   * Optional AR hook.
+   *
+   * @param target - The target entity view that became invisible.
+   */
+  onTargetLost(target) {
+  }
+  // ─── WebXR (VR / MR) hooks ────────────────────────────────────────────────
+  // Dispatched by XRSessionSystem / XRInteractionSystem, following the same
+  // pattern as the AR hooks above: public no-op methods that subclasses opt
+  // into by overriding. They never fire outside an immersive session.
+  /**
+   * Called once when an immersive session starts. Optional XR hook.
+   *
+   * Use it to set up XR-only state. Inspect `capabilities` rather than guessing
+   * by device: feature support differs sharply per headset (for example Vision
+   * Pro grants no passthrough on the web today).
+   *
+   * @param capabilities - What the session actually granted, read from
+   *   `XRSession.enabledFeatures`.
+   */
+  onXRSessionStart(capabilities) {
+  }
+  /** Called once when the immersive session ends. Optional XR hook. */
+  onXRSessionEnd() {
+  }
+  /**
+   * Called when a primary action begins — controller trigger, hand pinch, or
+   * Vision Pro gaze-pinch. Optional XR hook.
+   *
+   * @param input - Normalized state for the source that acted.
+   */
+  onSelectStart(input) {
+  }
+  /** Called when the primary action ends. Optional XR hook. */
+  onSelectEnd(input) {
+  }
+  /**
+   * Called when this entity is grabbed. Optional XR hook.
+   *
+   * Only fires for entities carrying an enabled, grabbable
+   * `XRInteractableComponent`.
+   *
+   * @param input - The source doing the grabbing.
+   */
+  /**
+   * A SECOND hand joined a two-hand grab on this entity.
+   *
+   * The first hand anchors the object and keeps holding it; this fires for the
+   * hand that came second — the foregrip on a rifle, say.
+   */
+  onSecondaryGrab(_input) {
+  }
+  /** The second hand let go, leaving the object in the first hand alone. */
+  onSecondaryRelease(_input) {
+  }
+  /**
+   * A hand pose declared on this entity started being held.
+   *
+   * Fires once the pose has been sustained for its hold time, not the instant
+   * the fingers pass through it.
+   */
+  onHandPoseStart(_event) {
+  }
+  /** A held hand pose ended, or its hand stopped being tracked. */
+  onHandPoseEnd(_event) {
+  }
+  onGrab(input) {
+  }
+  /** Called when this entity is released. Optional XR hook. */
+  onRelease(input) {
+  }
+  /** A UI button on this entity (or a descendant) was clicked. Clicks fire on
+   * RELEASE while still pointing at the widget — sliding off cancels. */
+  onUiPress(_event) {
+  }
+  /** A pointer began hovering a UI widget on this entity (or a descendant). */
+  onUiHoverStart(_event) {
+  }
+  /** The pointer left the widget. */
+  onUiHoverEnd(_event) {
+  }
+  /** A UI toggle flipped; `event.value` is the new boolean. */
+  onUiToggle(_event) {
+  }
+  /** A UI slider moved; `event.value` is the new number. Fires on real value
+   * changes during the drag and once more on release. */
+  onUiChange(_event) {
+  }
+};
+__name(_Behaviour, "Behaviour");
+/**
+ * Static marker used by `ScriptBehaviourSystem` to detect `Behaviour`
+ * subclasses across bundle-identity splits (esbuild may produce a second
+ * copy of the package when scripts are bundled, breaking `instanceof`).
+ * Inherited by every subclass via the prototype chain.
+ *
+ * @internal
+ */
+_Behaviour.__reluBehaviourClass = true;
+var Behaviour = _Behaviour;
+
+// core/systems/scriptShared.ts
+function reportScriptError(world, report, error) {
+  const reporter = world.reportScriptError;
+  if (typeof reporter === "function") {
+    reporter.call(world, report, error);
+    return;
+  }
+  console.error(
+    `[spatial-ecs] ${report.className || "Script"} failed in ${report.phase} (entity ${report.entityId}):`,
+    error
+  );
+}
+__name(reportScriptError, "reportScriptError");
+function reportBehaviourHookError(world, entityId, instance, hook, error) {
+  let scriptUrl = "";
+  let className = instance?.constructor?.name ?? "";
+  const script = typeof world.getComponent === "function" ? world.getComponent(entityId, ScriptComponent) : void 0;
+  if (script?.scriptInstances && Array.isArray(script.entries)) {
+    const entries = script.entries.filter(
+      (entry) => entry && (entry.className || entry.scriptUrl)
+    );
+    for (const [index, live] of script.scriptInstances) {
+      if (live !== instance) continue;
+      const entry = entries[index];
+      if (entry) {
+        scriptUrl = typeof entry.scriptUrl === "string" ? entry.scriptUrl : "";
+        className = typeof entry.className === "string" && entry.className ? entry.className : className;
+      }
+      break;
+    }
+  }
+  reportScriptError(
+    world,
+    { entityId, scriptUrl, className, phase: hook, source: "behaviour" },
+    error
+  );
+}
+__name(reportBehaviourHookError, "reportBehaviourHookError");
+
+// core/network/snapshotBuffer.ts
+var MAX_SNAPSHOTS = 32;
+function lerpPose(a, b, t) {
+  const dot = a.qx * b.qx + a.qy * b.qy + a.qz * b.qz + a.qw * b.qw;
+  const s = dot < 0 ? -1 : 1;
+  const qx = a.qx + (s * b.qx - a.qx) * t;
+  const qy = a.qy + (s * b.qy - a.qy) * t;
+  const qz = a.qz + (s * b.qz - a.qz) * t;
+  const qw = a.qw + (s * b.qw - a.qw) * t;
+  const len = Math.hypot(qx, qy, qz, qw) || 1;
+  return {
+    x: a.x + (b.x - a.x) * t,
+    y: a.y + (b.y - a.y) * t,
+    z: a.z + (b.z - a.z) * t,
+    qx: qx / len,
+    qy: qy / len,
+    qz: qz / len,
+    qw: qw / len
+  };
+}
+__name(lerpPose, "lerpPose");
+var _SnapshotBuffer = class _SnapshotBuffer {
+  constructor(teleportDistance = Number.POSITIVE_INFINITY) {
+    this.teleportDistance = teleportDistance;
+    this.snapshots = [];
+  }
+  push(at, pose) {
+    this.snapshots.push({ at, pose });
+    if (this.snapshots.length > MAX_SNAPSHOTS) this.snapshots.shift();
+  }
+  /** The pose at time `at`: holds the first and last, and never extrapolates. */
+  sample(at) {
+    const list = this.snapshots;
+    if (list.length === 0) return null;
+    if (at <= list[0].at) return list[0].pose;
+    for (let i = list.length - 1; i > 0; i--) {
+      const a = list[i - 1];
+      const b = list[i];
+      if (at < a.at) continue;
+      if (i > 1) this.snapshots = list.slice(i - 1);
+      if (at >= b.at) return b.pose;
+      const jump = Math.hypot(b.pose.x - a.pose.x, b.pose.y - a.pose.y, b.pose.z - a.pose.z);
+      if (jump > this.teleportDistance) return b.pose;
+      return lerpPose(a.pose, b.pose, (at - a.at) / (b.at - a.at));
+    }
+    return list[list.length - 1].pose;
+  }
+};
+__name(_SnapshotBuffer, "SnapshotBuffer");
+var SnapshotBuffer = _SnapshotBuffer;
+
+// core/network/NetworkSystem.ts
+var POSITION_EPSILON = 1e-3;
+var ROTATION_EPSILON = 5e-4;
+var euler = new THREE5__namespace.Euler();
+var quat = new THREE5__namespace.Quaternion();
+function poseOf(transform) {
+  const { position: p, rotation: r } = transform;
+  quat.setFromEuler(euler.set(r.x, r.y, r.z));
+  return { x: p.x, y: p.y, z: p.z, qx: quat.x, qy: quat.y, qz: quat.z, qw: quat.w };
+}
+__name(poseOf, "poseOf");
+function applyPose(transform, pose, rotation) {
+  transform.position.x = pose.x;
+  transform.position.y = pose.y;
+  transform.position.z = pose.z;
+  if (!rotation) return;
+  euler.setFromQuaternion(quat.set(pose.qx, pose.qy, pose.qz, pose.qw));
+  transform.rotation.x = euler.x;
+  transform.rotation.y = euler.y;
+  transform.rotation.z = euler.z;
+}
+__name(applyPose, "applyPose");
+var moved = /* @__PURE__ */ __name((a, b) => Math.abs(a.x - b.x) > POSITION_EPSILON || Math.abs(a.y - b.y) > POSITION_EPSILON || Math.abs(a.z - b.z) > POSITION_EPSILON || Math.abs(a.qx - b.qx) > ROTATION_EPSILON || Math.abs(a.qy - b.qy) > ROTATION_EPSILON || Math.abs(a.qz - b.qz) > ROTATION_EPSILON || Math.abs(a.qw - b.qw) > ROTATION_EPSILON, "moved");
+function encodeProps(props) {
+  return Object.fromEntries(
+    Object.entries(props ?? {}).map(([k, v]) => [k, JSON.stringify(v)])
+  );
+}
+__name(encodeProps, "encodeProps");
+var _NetworkSystem = class _NetworkSystem {
+  constructor(now = () => performance.now()) {
+    this.now = now;
+    this.world = null;
+    this.transport = null;
+    this.tracked = /* @__PURE__ */ new Map();
+    this.byEntity = /* @__PURE__ */ new Map();
+    this.listeners = /* @__PURE__ */ new Map();
+    this.handles = /* @__PURE__ */ new Map();
+    this.spawnedAvatar = false;
+  }
+  /** Join the shared world. Call after hydrating, so scene objects exist. */
+  connect(world, transport) {
+    this.world = world;
+    this.transport = transport;
+    world.setNetwork(this);
+    transport.onEntityAdd((e) => this.entityAdded(e));
+    transport.onEntityChange((e) => this.entityChanged(e));
+    transport.onEntityRemove((id) => this.entityRemoved(id));
+    transport.onPlayerJoin((id) => this.dispatch("onPlayerJoin", id));
+    transport.onPlayerLeave((id) => this.dispatch("onPlayerLeave", id));
+    transport.onMessage((name, payload, from) => {
+      for (const fn of this.listeners.get(name) ?? []) fn(payload, from);
+    });
+    transport.onCorrect((id, pose) => this.corrected(id, pose));
+    transport.onClose(() => this.disconnected());
+    this.registerScene();
+    this.spawnAvatar();
+  }
+  /** Scene objects: every client hydrates the same scene, so their ids already match. */
+  registerScene() {
+    const world = this.world;
+    const transport = this.transport;
+    if (!world || !transport) return;
+    const entities = [];
+    for (const entityId of world.query(NetworkIdentityComponent)) {
+      const identity = world.getComponent(entityId, NetworkIdentityComponent);
+      if (!identity || identity.networkId) continue;
+      identity.networkId = `scene-${entityId}`;
+      const transform = world.getComponent(entityId, TransformComponent);
+      const props = world.getComponent(entityId, NetworkedPropsComponent);
+      const tracked = this.track(identity.networkId, entityId, "", null);
+      tracked.props = encodeProps(props?.values);
+      entities.push({
+        id: identity.networkId,
+        props: tracked.props,
+        ...transform ? poseOf(transform) : { x: 0, y: 0, z: 0, qx: 0, qy: 0, qz: 0, qw: 1 }
+      });
+    }
+    if (entities.length) transport.registerScene(entities);
+  }
+  spawnAvatar() {
+    const world = this.world;
+    if (!world || this.spawnedAvatar) return;
+    const [entityId] = world.query(NetworkSpawnerComponent);
+    if (entityId === void 0) return;
+    const spawner = world.getComponent(entityId, NetworkSpawnerComponent);
+    if (!spawner?.playerPrefab) return;
+    this.spawnedAvatar = true;
+    const at = world.getComponent(entityId, TransformComponent)?.position;
+    const angle = Math.random() * Math.PI * 2;
+    this.spawn(spawner.playerPrefab, {
+      position: {
+        x: (at?.x ?? 0) + Math.cos(angle) * spawner.spawnRadius,
+        y: at?.y ?? 0,
+        z: (at?.z ?? 0) + Math.sin(angle) * spawner.spawnRadius
+      }
+    });
+  }
+  track(id, entityId, owner, view2) {
+    const entry = {
+      id,
+      entityId,
+      owner,
+      buffer: new SnapshotBuffer(),
+      sentAt: 0,
+      sent: null,
+      props: {}
+    };
+    if (view2) entry.buffer.push(this.now(), view2);
+    this.tracked.set(id, entry);
+    if (entityId !== null) this.byEntity.set(entityId, entry);
+    return entry;
+  }
+  /** The buffer needs the entity's own teleport setting, known once the entity exists. */
+  bindEntity(entry, entityId) {
+    const world = this.world;
+    if (!world) return;
+    entry.entityId = entityId;
+    this.byEntity.set(entityId, entry);
+    let identity = world.getComponent(entityId, NetworkIdentityComponent);
+    if (!identity) {
+      identity = new NetworkIdentityComponent();
+      world.addComponent(entityId, identity);
+    }
+    identity.networkId = entry.id;
+    identity.owner = entry.owner;
+    const settings = world.getComponent(entityId, NetworkTransformComponent);
+    entry.buffer = new SnapshotBuffer(settings?.teleportDistance);
+  }
+  entityAdded(view2) {
+    const existing = this.tracked.get(view2.id);
+    if (existing) {
+      this.entityChanged(view2);
+      return;
+    }
+    const entry = this.track(view2.id, null, view2.owner, view2);
+    if (!view2.prefab || !this.world) return;
+    euler.setFromQuaternion(quat.set(view2.qx, view2.qy, view2.qz, view2.qw));
+    void spawnPrefab(this.world, view2.prefab, {
+      position: { x: view2.x, y: view2.y, z: view2.z },
+      rotation: { x: euler.x, y: euler.y, z: euler.z }
+    }).then((entityId) => {
+      if (this.tracked.get(view2.id) !== entry) {
+        if (this.world) despawnPrefab(this.world, entityId);
+        return;
+      }
+      this.bindEntity(entry, entityId);
+      entry.buffer.push(this.now(), view2);
+      this.applyProps(entry, view2.props);
+    });
+  }
+  entityChanged(view2) {
+    const entry = this.tracked.get(view2.id);
+    if (!entry) return;
+    entry.owner = view2.owner;
+    if (entry.entityId !== null && this.world) {
+      const identity = this.world.getComponent(entry.entityId, NetworkIdentityComponent);
+      if (identity) identity.owner = view2.owner;
+    }
+    if (view2.owner !== this.transport?.sessionId) entry.buffer.push(this.now(), view2);
+    this.applyProps(entry, view2.props);
+  }
+  entityRemoved(id) {
+    const entry = this.tracked.get(id);
+    if (!entry) return;
+    this.tracked.delete(id);
+    if (entry.entityId === null) return;
+    this.byEntity.delete(entry.entityId);
+    if (this.world) despawnPrefab(this.world, entry.entityId);
+  }
+  applyProps(entry, props) {
+    if (entry.entityId === null || !this.world) return;
+    for (const [key, json] of Object.entries(props)) {
+      if (entry.props[key] === json) continue;
+      entry.props[key] = json;
+      const value = JSON.parse(json);
+      let component = this.world.getComponent(entry.entityId, NetworkedPropsComponent);
+      if (!component) {
+        component = new NetworkedPropsComponent();
+        this.world.addComponent(entry.entityId, component);
+      }
+      component.values[key] = value;
+      this.dispatch("onNetworkProp", key, value, entry.entityId);
+    }
+  }
+  corrected(id, pose) {
+    const entry = this.tracked.get(id);
+    if (entry?.entityId == null || !this.world) return;
+    const transform = this.world.getComponent(entry.entityId, TransformComponent);
+    if (transform) applyPose(transform, pose, true);
+    entry.sent = pose;
+  }
+  disconnected() {
+    this.transport = null;
+    this.world?.setNetwork(null);
+  }
+  dispatch(hook, a, b, on) {
+    const world = this.world;
+    if (!world) return;
+    const ids = on !== void 0 ? [on] : world.query(ScriptComponent);
+    for (const entityId of ids) {
+      const instances = world.getComponent(entityId, ScriptComponent)?.scriptInstances;
+      for (const instance of instances?.values() ?? []) {
+        if (!(instance instanceof Behaviour)) continue;
+        try {
+          instance[hook]?.(a, b);
+        } catch (error) {
+          reportBehaviourHookError(world, entityId, instance, hook, error);
+        }
+      }
+    }
+  }
+  update(world) {
+    const transport = this.transport;
+    if (!transport) return;
+    const now = this.now();
+    for (const entry of this.tracked.values()) {
+      if (entry.entityId === null) continue;
+      const settings = world.getComponent(entry.entityId, NetworkTransformComponent);
+      if (!settings?.enabled) continue;
+      const transform = world.getComponent(entry.entityId, TransformComponent);
+      if (!transform) continue;
+      if (entry.owner === transport.sessionId) {
+        if (now - entry.sentAt < 1e3 / settings.sendRate) continue;
+        const pose = poseOf(transform);
+        if (entry.sent && !moved(entry.sent, pose)) continue;
+        entry.sentAt = now;
+        entry.sent = pose;
+        transport.sendPose(entry.id, pose);
+      } else {
+        const pose = entry.buffer.sample(now - settings.interpolationMs);
+        if (pose) applyPose(transform, pose, settings.syncRotation);
+      }
+    }
+  }
+  dispose() {
+    this.transport?.leave();
+    this.transport = null;
+    this.world?.setNetwork(null);
+    this.tracked.clear();
+    this.byEntity.clear();
+    this.handles.clear();
+    this.listeners.clear();
+  }
+  spawn(prefab, options = {}) {
+    const p = options.position;
+    const r = options.rotation;
+    quat.setFromEuler(euler.set(r?.x ?? 0, r?.y ?? 0, r?.z ?? 0));
+    this.transport?.spawn({
+      prefab: typeof prefab === "string" ? prefab : prefab.path,
+      props: encodeProps(options.props),
+      x: p?.x ?? 0,
+      y: p?.y ?? 0,
+      z: p?.z ?? 0,
+      qx: quat.x,
+      qy: quat.y,
+      qz: quat.z,
+      qw: quat.w
+    });
+  }
+  handleFor(entityId) {
+    const known = this.handles.get(entityId);
+    if (known) return known;
+    const self = this;
+    const entry = /* @__PURE__ */ __name(() => self.byEntity.get(entityId), "entry");
+    const handle = {
+      get connected() {
+        return self.transport !== null;
+      },
+      get sessionId() {
+        return self.transport?.sessionId ?? "";
+      },
+      get isHost() {
+        const t = self.transport;
+        return Boolean(t) && t?.host === t?.sessionId;
+      },
+      get isOwner() {
+        return entry()?.owner === self.transport?.sessionId;
+      },
+      get players() {
+        return self.transport?.players ?? [];
+      },
+      send: /* @__PURE__ */ __name((name, payload) => self.transport?.send(name, payload ?? null), "send"),
+      onMessage: /* @__PURE__ */ __name((name, fn) => {
+        const set = self.listeners.get(name) ?? /* @__PURE__ */ new Set();
+        self.listeners.set(name, set);
+        set.add(fn);
+        return () => set.delete(fn);
+      }, "onMessage"),
+      spawn: /* @__PURE__ */ __name((prefab, options) => self.spawn(prefab, options), "spawn"),
+      despawn: /* @__PURE__ */ __name((id = entityId) => {
+        const target = self.byEntity.get(id);
+        if (target) self.transport?.despawn(target.id);
+      }, "despawn"),
+      setProp: /* @__PURE__ */ __name((key, value) => {
+        const target = entry();
+        if (!target || target.entityId === null || !self.world) return;
+        const json = JSON.stringify(value);
+        target.props[key] = json;
+        let component = self.world.getComponent(target.entityId, NetworkedPropsComponent);
+        if (!component) {
+          component = new NetworkedPropsComponent();
+          self.world.addComponent(target.entityId, component);
+        }
+        component.values[key] = value;
+        self.transport?.setProp(target.id, key, json);
+      }, "setProp"),
+      getProp: /* @__PURE__ */ __name((key) => self.world?.getComponent(entityId, NetworkedPropsComponent)?.values[key], "getProp")
+    };
+    this.handles.set(entityId, handle);
+    return handle;
+  }
+};
+__name(_NetworkSystem, "NetworkSystem");
+var NetworkSystem = _NetworkSystem;
+
+exports.ColyseusTransport = ColyseusTransport;
+exports.NetworkSystem = NetworkSystem;
+exports.SnapshotBuffer = SnapshotBuffer;
+exports.withLatency = withLatency;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map