@relu-interactives/spatial-ecs 0.2.2

package/dist/index.js

@@ -0,0 +1,1729 @@
+import { MeshGeometrySystem, EnvironmentSyncSystem, PostprocessingSyncSystem, LightSyncSystem, MaterialSyncSystem, PhysicsSyncSystem, AnimationSystem, AudioSystem, VideoSystem, CameraSyncSystem, TransformSyncSystem, ObjectVisibilitySystem, RenderSystem } from './chunk-P2YDX5DB.js';
+export { AnimationSystem, AudioSystem, Behaviour, CameraSyncSystem, EnvironmentSyncSystem, InputSystem, KeyboardKeys, LightSyncSystem, MaterialSyncSystem, MeshGeometrySystem, ObjectVisibilitySystem, PhysicsSyncSystem, PostprocessingSyncSystem, RenderSystem, ScriptBehaviourSystem, TransformSyncSystem, VideoSystem } from './chunk-P2YDX5DB.js';
+import { registerDefaultFactories } from './chunk-XWIEEJ7Z.js';
+export { createAnimationComponent, createAudioComponent, createCameraComponent, createEntityTypeComponent, createEnvironmentComponent, createImageComponent, createImageTargetAnchorComponent, createImageTargetComponent, createLightComponent, createMaterialComponent, createMeshComponent, createMeshGeometryComponent, createModelComponent, createNameComponent, createObject3DRefComponent, createParentIdComponent, createPhysicsComponent, createPostprocessingComponent, createScriptComponent, createSelectableComponent, createSelectionTransformStateComponent, createSpriteComponent, createTransformComponent, createVideoComponent, registerDefaultComponentFactories, registerDefaultFactories } from './chunk-XWIEEJ7Z.js';
+import { ObjectManagementSystem, applyTransform } from './chunk-AYEF3X2P.js';
+export { ObjectManagementSystem } from './chunk-AYEF3X2P.js';
+import { SelectionTransformState, Object3DRef, Name, EntityType, ScriptComponent, AnimationComponent, TransformComponent, ModelComponent, ImageComponent, SpriteComponent, VideoComponent, AudioComponent, CameraComponent, Environment, Postprocessing, ImageTarget, LightComponent, MaterialComponent, MeshGeometryComponent, Selectable, PhysicsComponent } from './chunk-MAWBTMCG.js';
+export { AnimationStateMachine, AnimationStateManager, components_exports as CoreComponents } from './chunk-MAWBTMCG.js';
+import './chunk-QHILSPT4.js';
+import { normalizeDebugValue, DEBUG_CHANGE_IGNORED_SYSTEMS, cloneHistoryValue } from './chunk-NFDTIYR4.js';
+import { __name } from './chunk-OY7ZODZP.js';
+export { Component } from './chunk-OY7ZODZP.js';
+import * as THREE from 'three';
+
+var _World = class _World {
+  constructor(options) {
+    this.nextEntityId = 1;
+    this.entities = /* @__PURE__ */ new Set();
+    this.systems = [];
+    this.selectionListeners = /* @__PURE__ */ new Set();
+    this.storeListeners = /* @__PURE__ */ new Set();
+    this.components = /* @__PURE__ */ new Map();
+    this.inputSystem = null;
+    this.rapierModule = null;
+    this.rapierModulePromise = null;
+    this.physicsWorld = null;
+    this.isEditor = false;
+    this.paused = false;
+    this.scene = options.scene;
+    this.camera = options.camera;
+    this.renderer = options.renderer;
+    this.featureFlags = {
+      supportSkybox: options.featureFlags?.supportSkybox ?? true,
+      supportPostprocessing: options.featureFlags?.supportPostprocessing ?? true
+    };
+    this.renderer.shadowMap.enabled = true;
+  }
+  createEntity() {
+    const entityId = this.nextEntityId;
+    this.nextEntityId += 1;
+    this.entities.add(entityId);
+    this.emitStoreChanged();
+    return entityId;
+  }
+  destroyEntity(entityId) {
+    if (!this.entities.has(entityId)) {
+      return;
+    }
+    this.entities.delete(entityId);
+    for (const store of this.components.values()) {
+      store.delete(entityId);
+    }
+    if (this.getSelectedEntity() === entityId) {
+      this.setSelectedEntity(null);
+    }
+    this.emitStoreChanged();
+  }
+  getSelectionState() {
+    const entityId = this.query(SelectionTransformState)[0];
+    if (entityId === void 0) {
+      return void 0;
+    }
+    return this.getComponent(entityId, SelectionTransformState);
+  }
+  hasEntity(entityId) {
+    return this.entities.has(entityId);
+  }
+  getEntities() {
+    return [...this.entities];
+  }
+  getEntityCount() {
+    return this.entities.size;
+  }
+  addComponent(entityId, component) {
+    if (!this.entities.has(entityId)) {
+      throw new Error(`Cannot add component to missing entity ${entityId}`);
+    }
+    const componentType = component.constructor;
+    if (!this.components.has(componentType)) {
+      this.components.set(componentType, /* @__PURE__ */ new Map());
+    }
+    this.components.get(componentType)?.set(entityId, component);
+    this.emitStoreChanged();
+  }
+  addComponents(entityId, components) {
+    if (!this.entities.has(entityId)) {
+      throw new Error(`Cannot add component to missing entity ${entityId}`);
+    }
+    for (const component of components) {
+      const componentType = component.constructor;
+      if (!this.components.has(componentType)) {
+        this.components.set(componentType, /* @__PURE__ */ new Map());
+      }
+      this.components.get(componentType)?.set(entityId, component);
+    }
+    this.emitStoreChanged();
+  }
+  removeComponent(entityId, componentType) {
+    this.components.get(componentType)?.delete(entityId);
+    this.emitStoreChanged();
+  }
+  getComponent(entityId, componentType) {
+    return this.components.get(componentType)?.get(entityId);
+  }
+  hasComponent(entityId, componentType) {
+    return this.components.get(componentType)?.has(entityId) ?? false;
+  }
+  query(...componentTypes) {
+    return [...this.entities].filter(
+      (entityId) => componentTypes.every(
+        (componentType) => this.components.get(componentType)?.has(entityId)
+      )
+    );
+  }
+  /**
+   * Returns `true` if the entity is currently visible (its `Object3DRef.visibility`
+   * is `true`), or if the entity has no `Object3DRef` component (entities without a
+   * scene object are always considered active). Systems use this to skip per-entity
+   * updates for hidden objects.
+   */
+  isEntityVisible(entityId) {
+    const objectRef = this.getComponent(entityId, Object3DRef);
+    return objectRef ? objectRef.visibility : true;
+  }
+  getInputSystem() {
+    if (this.inputSystem !== null) return this.inputSystem;
+    const inputSystem = this.systems.find(
+      (system) => system.constructor.name === "InputSystem"
+    );
+    this.inputSystem = inputSystem;
+    return inputSystem ?? null;
+  }
+  getKeyDown(key) {
+    const inputSystem = this.getInputSystem();
+    if (!inputSystem) {
+      return false;
+    }
+    return inputSystem.getKeyDown(key);
+  }
+  getKeyUp(key) {
+    const inputSystem = this.getInputSystem();
+    if (!inputSystem) {
+      return false;
+    }
+    return inputSystem.getKeyUp(key);
+  }
+  getKey(key) {
+    const inputSystem = this.getInputSystem();
+    if (!inputSystem) {
+      return false;
+    }
+    return inputSystem.getKey(key);
+  }
+  getMouse(button) {
+    const inputSystem = this.getInputSystem();
+    if (!inputSystem) {
+      return false;
+    }
+    return inputSystem.getMouse(button);
+  }
+  getMouseDown(button) {
+    const inputSystem = this.getInputSystem();
+    if (!inputSystem) {
+      return false;
+    }
+    return inputSystem.getMouseDown(button);
+  }
+  getMouseUp(button) {
+    const inputSystem = this.getInputSystem();
+    if (!inputSystem) {
+      return false;
+    }
+    return inputSystem.getMouseUp(button);
+  }
+  getScrollClick() {
+    const inputSystem = this.getInputSystem();
+    if (!inputSystem) {
+      return false;
+    }
+    return inputSystem.getScrollClick();
+  }
+  getScrollClickDown() {
+    const inputSystem = this.getInputSystem();
+    if (!inputSystem) {
+      return false;
+    }
+    return inputSystem.getScrollClickDown();
+  }
+  getScrollClickUp() {
+    const inputSystem = this.getInputSystem();
+    if (!inputSystem) {
+      return false;
+    }
+    return inputSystem.getScrollClickUp();
+  }
+  getScrollDelta() {
+    const inputSystem = this.getInputSystem();
+    if (!inputSystem) {
+      return { x: 0, y: 0 };
+    }
+    return inputSystem.getScrollDelta();
+  }
+  consumeScrollDelta() {
+    const inputSystem = this.getInputSystem();
+    if (!inputSystem) {
+      return { x: 0, y: 0 };
+    }
+    return inputSystem.consumeScrollDelta();
+  }
+  getMousePosition() {
+    const inputSystem = this.getInputSystem();
+    if (!inputSystem) {
+      return { x: 0, y: 0 };
+    }
+    return inputSystem.getMousePosition();
+  }
+  getMouseDelta() {
+    const inputSystem = this.getInputSystem();
+    if (!inputSystem) {
+      return { x: 0, y: 0 };
+    }
+    return inputSystem.getMouseDelta();
+  }
+  consumeMouseDelta() {
+    const inputSystem = this.getInputSystem();
+    if (!inputSystem) {
+      return { x: 0, y: 0 };
+    }
+    return inputSystem.consumeMouseDelta();
+  }
+  async getRapierModule() {
+    if (this.rapierModule) {
+      return this.rapierModule;
+    }
+    if (!this.rapierModulePromise) {
+      this.rapierModulePromise = import('@dimforge/rapier3d-compat').then(
+        async (moduleValue) => {
+          await moduleValue.init();
+          this.rapierModule = moduleValue;
+          return moduleValue;
+        }
+      );
+    }
+    return this.rapierModulePromise;
+  }
+  getPhysicsWorld() {
+    return this.physicsWorld;
+  }
+  setPhysicsWorld(physicsWorld) {
+    this.physicsWorld = physicsWorld;
+  }
+  async createPhysicsWorld(options) {
+    if (this.physicsWorld) {
+      return this.physicsWorld;
+    }
+    const RAPIER = await this.getRapierModule();
+    const gravity = options?.gravity;
+    const gravityVector = new RAPIER.Vector3(
+      typeof gravity?.x === "number" ? gravity.x : 0,
+      typeof gravity?.y === "number" ? gravity.y : -9.81,
+      typeof gravity?.z === "number" ? gravity.z : 0
+    );
+    this.physicsWorld = new RAPIER.World(gravityVector);
+    return this.physicsWorld;
+  }
+  lockMousePointer() {
+    const inputSystem = this.getInputSystem();
+    if (inputSystem) {
+      inputSystem.setPointerLockElement(
+        this.renderer.domElement
+      );
+      return inputSystem.lockMousePointer();
+    }
+    if (typeof document === "undefined") {
+      return false;
+    }
+    if (typeof this.renderer.domElement.requestPointerLock !== "function") {
+      return false;
+    }
+    try {
+      const result = this.renderer.domElement.requestPointerLock();
+      if (result instanceof Promise) {
+        result.catch(() => {
+        });
+      }
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  unlockMousePointer() {
+    const inputSystem = this.getInputSystem();
+    if (inputSystem) {
+      return inputSystem.unlockMousePointer();
+    }
+    if (typeof document === "undefined") {
+      return false;
+    }
+    if (!document.pointerLockElement || typeof document.exitPointerLock !== "function") {
+      return false;
+    }
+    document.exitPointerLock();
+    return true;
+  }
+  isMousePointerLocked() {
+    const inputSystem = this.getInputSystem();
+    if (inputSystem) {
+      inputSystem.setPointerLockElement(
+        this.renderer.domElement
+      );
+      return inputSystem.isMousePointerLocked();
+    }
+    if (typeof document === "undefined") {
+      return false;
+    }
+    return document.pointerLockElement === this.renderer.domElement;
+  }
+  getSystem(system) {
+    const resolvedSystem = this.systems.find((candidate) => {
+      return candidate === system || candidate.constructor === system.constructor;
+    });
+    if (!resolvedSystem) {
+      const systemName = system.constructor?.name || "AnonymousSystem";
+      throw new Error(
+        `System '${systemName}' is not registered in this world.`
+      );
+    }
+    return resolvedSystem;
+  }
+  hasSystem(system) {
+    return this.systems.includes(system) || this.systems.some(
+      (candidate) => candidate.constructor === system.constructor
+    );
+  }
+  addSystem(system) {
+    this.systems.push(system);
+  }
+  addSystems(systems) {
+    for (const system of systems) {
+      this.addSystem(system);
+    }
+  }
+  setup({ systems, isEditor }) {
+    const objectManagementSystem = new ObjectManagementSystem(
+      this.scene,
+      this.camera,
+      isEditor ?? false
+    );
+    const meshGeometrySystem = new MeshGeometrySystem();
+    const environmentSyncSystem = this.featureFlags.supportSkybox ? new EnvironmentSyncSystem(this.scene) : null;
+    const postprocessingSyncSystem = this.featureFlags.supportPostprocessing ? new PostprocessingSyncSystem(this.renderer, this.scene, this.camera) : null;
+    const lightSyncSystem = new LightSyncSystem();
+    const materialSyncSystem = new MaterialSyncSystem();
+    const physicsSyncSystem = new PhysicsSyncSystem({
+      isEditor: isEditor ?? false
+    });
+    const animationSystem = new AnimationSystem();
+    const audioSystem = new AudioSystem({ isEditor: isEditor ?? false });
+    const videoSystem = new VideoSystem({ isEditor: isEditor ?? false });
+    const cameraSyncSystem = new CameraSyncSystem();
+    const transformSyncSystem = new TransformSyncSystem();
+    const objectVisibilitySystem = new ObjectVisibilitySystem();
+    const renderSystem = new RenderSystem(
+      this.renderer,
+      this.scene,
+      this.camera
+    );
+    registerDefaultFactories(objectManagementSystem);
+    this.inputSystem = null;
+    const coreSystems = [
+      objectManagementSystem,
+      meshGeometrySystem
+    ];
+    if (environmentSyncSystem) {
+      coreSystems.push(environmentSyncSystem);
+    }
+    if (postprocessingSyncSystem) {
+      coreSystems.push(postprocessingSyncSystem);
+    }
+    this.addSystems([
+      ...coreSystems,
+      physicsSyncSystem,
+      ...systems,
+      objectVisibilitySystem,
+      lightSyncSystem,
+      materialSyncSystem,
+      animationSystem,
+      audioSystem,
+      videoSystem,
+      cameraSyncSystem,
+      transformSyncSystem,
+      renderSystem
+    ]);
+    const inputSystem = this.getInputSystem();
+    if (inputSystem) {
+      inputSystem.setPointerLockElement(
+        this.renderer.domElement
+      );
+    }
+    this.isEditor = isEditor ?? false;
+    return {
+      objectManagementSystem,
+      transformSyncSystem,
+      renderSystem
+    };
+  }
+  isEditorMode() {
+    return this.isEditor;
+  }
+  /**
+   * Pauses world simulation. While paused, `update()` skips all system ticks so
+   * physics, animation, scripts, and rendering stop advancing. The last rendered
+   * frame remains frozen on-screen.
+   *
+   * Call {@link resume} to continue.
+   */
+  pause() {
+    this.paused = true;
+  }
+  /**
+   * Resumes world simulation after a previous {@link pause} call.
+   * Has no effect if the world is not paused.
+   */
+  resume() {
+    this.paused = false;
+  }
+  /**
+   * Returns `true` if the world is currently paused.
+   *
+   * @example
+   * ```ts
+   * if (this.world.isPaused()) {
+   *   this.world.resume();
+   * }
+   * ```
+   */
+  isPaused() {
+    return this.paused;
+  }
+  getScene() {
+    return this.scene;
+  }
+  getCamera() {
+    return this.camera;
+  }
+  getRenderer() {
+    return this.renderer;
+  }
+  update(deltaTime) {
+    if (this.paused) return;
+    for (const system of this.systems) {
+      system.update(this, deltaTime);
+    }
+  }
+  dispose() {
+    for (const system of this.systems) {
+      system.dispose?.(this);
+    }
+    this.selectionListeners.clear();
+    this.storeListeners.clear();
+    this.physicsWorld = null;
+    this.systems = [];
+    this.paused = false;
+  }
+  setSelectedEntity(entityId) {
+    const state = this.getSelectionState();
+    if (!state) {
+      return;
+    }
+    const nextEntityId = entityId !== null && this.entities.has(entityId) ? entityId : null;
+    if (state.selectedEntityId === nextEntityId) {
+      return;
+    }
+    state.selectedEntityId = nextEntityId;
+    for (const listener of this.selectionListeners) {
+      listener(nextEntityId);
+    }
+    this.emitStoreChanged();
+  }
+  getSelectedEntity() {
+    return this.getSelectionState()?.selectedEntityId ?? null;
+  }
+  getEntityComponents(entityId) {
+    const components = [];
+    for (const store of this.components.values()) {
+      const component = store.get(entityId);
+      if (component) {
+        components.push(component);
+      }
+    }
+    return components;
+  }
+  getEntityName(entityId) {
+    const nameComponent = this.getComponent(entityId, Name);
+    const name = nameComponent?.value?.trim();
+    if (name) {
+      return name;
+    }
+    return `Entity ${entityId}`;
+  }
+  getEntityType(entityId) {
+    const typeComponent = this.getComponent(entityId, EntityType);
+    const type = typeComponent?.value?.trim();
+    if (type) {
+      return type;
+    }
+    return `EntityType ${entityId}`;
+  }
+  getObject3d(entityId) {
+    const object3DRefComponent = this.getComponent(entityId, Object3DRef);
+    const object = object3DRefComponent?.object;
+    if (object) {
+      return object;
+    }
+    return null;
+  }
+  toEntityView(entityId) {
+    return {
+      entityId,
+      name: this.getEntityName(entityId),
+      object: this.getObject3d(entityId),
+      type: this.getEntityType(entityId),
+      components: this.getEntityComponents(entityId)
+    };
+  }
+  getEntitiesByComponent(component) {
+    const componentType = component.constructor;
+    const entityStore = this.components.get(componentType);
+    if (!entityStore) {
+      return [];
+    }
+    return [...entityStore.keys()].filter((entityId) => this.entities.has(entityId)).sort((a, b) => a - b).map((entityId) => this.toEntityView(entityId));
+  }
+  getEntitiesByName(name) {
+    const searchName = name.trim();
+    if (!searchName) {
+      return [];
+    }
+    return this.getAllEntities().filter((entity) => entity.name === searchName);
+  }
+  getEntityByName(name) {
+    const [entity] = this.getEntitiesByName(name);
+    return entity ?? null;
+  }
+  getEntityById(entityId) {
+    if (!this.entities.has(entityId)) {
+      return null;
+    }
+    return this.toEntityView(entityId);
+  }
+  /**
+   * Cast a ray from `origin` along `direction` and return every intersected
+   * entity-bound mesh, sorted by distance. Each result is a standard
+   * `THREE.Intersection` augmented with the owning `entityId` (or `null` if
+   * the hit object is not part of any tracked entity).
+   *
+   * @param origin - World-space origin of the ray (`THREE.Vector3` or
+   *   `{ x, y, z }`).
+   * @param direction - World-space direction of the ray. Will be normalized
+   *   internally; magnitude is ignored.
+   * @param near - Minimum hit distance from the origin. Defaults to `0`.
+   * @param far - Maximum hit distance from the origin. Defaults to `Infinity`.
+   *
+   * @example
+   * ```ts
+   * const hits = world.raycast(
+   *   { x: 0, y: 1, z: 0 },
+   *   { x: 0, y: 0, z: -1 },
+   * );
+   * if (hits[0]?.entityId !== null) {
+   *   console.log("hit entity", hits[0].entityId, "at", hits[0].point);
+   * }
+   * ```
+   */
+  raycast(origin, direction, near = 0, far = Infinity) {
+    const rayOrigin = new THREE.Vector3(origin.x, origin.y, origin.z);
+    const rayDirection = new THREE.Vector3(
+      direction.x,
+      direction.y,
+      direction.z
+    );
+    if (rayDirection.lengthSq() === 0) {
+      return [];
+    }
+    rayDirection.normalize();
+    const raycaster = new THREE.Raycaster(rayOrigin, rayDirection, near, far);
+    const intersections = raycaster.intersectObjects(
+      this.scene.children,
+      true
+    );
+    const objectToEntity = this.buildObjectToEntityMap();
+    return intersections.map(
+      (intersection) => this.toIntersectionResult(intersection, objectToEntity)
+    );
+  }
+  /**
+   * Cast a ray from an entity's world-space position along its forward
+   * direction (the +Z axis of its world matrix). Returns intersected
+   * entity-bound meshes sorted by distance, with the source entity itself
+   * filtered out so the ray does not hit the caster.
+   *
+   * @param entityId - Entity to cast the ray from. Must have an `Object3DRef`.
+   * @param near - Minimum hit distance from the origin. Defaults to `0`.
+   * @param far - Maximum hit distance from the origin. Defaults to `Infinity`.
+   *
+   * @example
+   * ```ts
+   * const hits = world.raycastFrom(this.entityId, 0, 50);
+   * const closest = hits[0];
+   * if (closest && closest.entityId !== null) {
+   *   console.log("looking at", closest.entityId);
+   * }
+   * ```
+   */
+  raycastFrom(entityId, near = 0, far = Infinity) {
+    const sourceObject = this.getObject3d(entityId);
+    if (!sourceObject) {
+      return [];
+    }
+    const rayOrigin = new THREE.Vector3();
+    const rayDirection = new THREE.Vector3();
+    sourceObject.getWorldPosition(rayOrigin);
+    sourceObject.getWorldDirection(rayDirection);
+    if (rayDirection.lengthSq() === 0) {
+      return [];
+    }
+    const raycaster = new THREE.Raycaster(rayOrigin, rayDirection, near, far);
+    const intersections = raycaster.intersectObjects(
+      this.scene.children,
+      true
+    );
+    const objectToEntity = this.buildObjectToEntityMap();
+    return intersections.map(
+      (intersection) => this.toIntersectionResult(intersection, objectToEntity)
+    ).filter((result) => result.entityId !== entityId);
+  }
+  buildObjectToEntityMap() {
+    const map = /* @__PURE__ */ new Map();
+    const store = this.components.get(
+      Object3DRef
+    );
+    if (!store) {
+      return map;
+    }
+    for (const [entityId, component] of store) {
+      const object = component.object;
+      if (object) {
+        map.set(object, entityId);
+      }
+    }
+    return map;
+  }
+  resolveEntityForObject(object, objectToEntity) {
+    let current = object;
+    while (current) {
+      const entityId = objectToEntity.get(current);
+      if (entityId !== void 0) {
+        return entityId;
+      }
+      current = current.parent;
+    }
+    return null;
+  }
+  toIntersectionResult(intersection, objectToEntity) {
+    return {
+      entityId: this.resolveEntityForObject(
+        intersection.object,
+        objectToEntity
+      ),
+      threeResult: intersection
+    };
+  }
+  getEntityScript(entityId) {
+    if (!this.entities.has(entityId)) {
+      return null;
+    }
+    const scriptComponent = this.getComponent(entityId, ScriptComponent);
+    if (!scriptComponent || scriptComponent.scriptInstance === null) {
+      return null;
+    }
+    return scriptComponent.scriptInstance;
+  }
+  getScripts(className) {
+    const normalizedClassName = className.trim();
+    if (!normalizedClassName) {
+      return [];
+    }
+    const scriptEntityIds = this.query(ScriptComponent);
+    const instances = [];
+    for (const entityId of scriptEntityIds) {
+      const scriptComponent = this.getComponent(entityId, ScriptComponent);
+      if (!scriptComponent) {
+        continue;
+      }
+      const hasClassMatch = Array.isArray(scriptComponent.entries) ? scriptComponent.entries.some((entry) => {
+        if (!entry || typeof entry !== "object") {
+          return false;
+        }
+        const classNameValue = entry.className;
+        return typeof classNameValue === "string" && classNameValue === normalizedClassName;
+      }) : false;
+      if (!hasClassMatch) {
+        continue;
+      }
+      if (scriptComponent.scriptInstance !== null) {
+        instances.push(scriptComponent.scriptInstance);
+      }
+    }
+    return instances;
+  }
+  getScript(className) {
+    const [instance] = this.getScripts(className);
+    return instance ?? null;
+  }
+  getAllEntities() {
+    return [...this.entities].sort((a, b) => a - b).map((entityId) => this.toEntityView(entityId));
+  }
+  onSelectionChanged(listener) {
+    this.selectionListeners.add(listener);
+    return () => {
+      this.selectionListeners.delete(listener);
+    };
+  }
+  subscribe(listener) {
+    this.storeListeners.add(listener);
+    return () => {
+      this.storeListeners.delete(listener);
+    };
+  }
+  getDebugSnapshot(maxDepth = 3) {
+    const components = [...this.components.entries()].map(([componentClass, store]) => {
+      return {
+        component: componentClass.name,
+        entries: [...store.entries()].map(([entityId, component]) => {
+          return {
+            entityId,
+            value: normalizeDebugValue(component, {
+              seen: /* @__PURE__ */ new WeakSet(),
+              depth: 0,
+              maxDepth
+            })
+          };
+        }).sort((a, b) => a.entityId - b.entityId)
+      };
+    }).sort((a, b) => a.component.localeCompare(b.component));
+    const systems = this.systems.map((system) => {
+      const systemName = system.constructor?.name || "AnonymousSystem";
+      return {
+        system,
+        systemName
+      };
+    }).filter(({ systemName }) => !DEBUG_CHANGE_IGNORED_SYSTEMS.has(systemName)).map(({ system, systemName }) => {
+      return {
+        system: systemName,
+        state: normalizeDebugValue(system, {
+          seen: /* @__PURE__ */ new WeakSet(),
+          depth: 0,
+          maxDepth
+        })
+      };
+    });
+    return {
+      selectedEntityId: this.getSelectedEntity(),
+      entities: [...this.entities].sort((a, b) => a - b),
+      nextEntityId: this.nextEntityId,
+      components,
+      systems
+    };
+  }
+  getDebugSignature(maxDepth = 3) {
+    return JSON.stringify(this.getDebugSnapshot(maxDepth));
+  }
+  createHistorySnapshot() {
+    return {
+      selectedEntityId: this.getSelectedEntity(),
+      entities: [...this.entities],
+      nextEntityId: this.nextEntityId,
+      components: [...this.components.entries()].map(
+        ([componentType, store]) => {
+          return {
+            componentType,
+            entries: [...store.entries()].map(([entityId, component]) => {
+              return {
+                entityId,
+                component: cloneHistoryValue(component)
+              };
+            })
+          };
+        }
+      )
+    };
+  }
+  applyHistorySnapshot(snapshot) {
+    const previousSelectedEntityId = this.getSelectedEntity();
+    this.nextEntityId = snapshot.nextEntityId;
+    this.entities = new Set(snapshot.entities);
+    const nextComponents = /* @__PURE__ */ new Map();
+    for (const componentBlock of snapshot.components) {
+      const store = /* @__PURE__ */ new Map();
+      for (const entry of componentBlock.entries) {
+        if (!this.entities.has(entry.entityId)) {
+          continue;
+        }
+        store.set(entry.entityId, cloneHistoryValue(entry.component));
+      }
+      nextComponents.set(componentBlock.componentType, store);
+    }
+    this.components = nextComponents;
+    const selectionState = this.getSelectionState();
+    const nextSelectedEntityId = snapshot.selectedEntityId !== null && this.entities.has(snapshot.selectedEntityId) ? snapshot.selectedEntityId : null;
+    if (selectionState) {
+      selectionState.selectedEntityId = nextSelectedEntityId;
+    }
+    const selectionChanged = previousSelectedEntityId !== nextSelectedEntityId;
+    if (selectionChanged) {
+      for (const listener of this.selectionListeners) {
+        listener(nextSelectedEntityId);
+      }
+    }
+    this.emitStoreChanged();
+  }
+  emitStoreChanged() {
+    for (const listener of this.storeListeners) {
+      listener();
+    }
+  }
+};
+__name(_World, "World");
+var World = _World;
+
+// core/hydration/readers.ts
+function asRecord(value) {
+  if (!value || typeof value !== "object") {
+    return null;
+  }
+  return value;
+}
+__name(asRecord, "asRecord");
+function readString(value) {
+  if (typeof value === "string") {
+    return value;
+  }
+  const record = asRecord(value);
+  if (!record) {
+    return null;
+  }
+  return typeof record.value === "string" ? record.value : null;
+}
+__name(readString, "readString");
+function readTransform(value) {
+  const record = asRecord(value);
+  if (!record) {
+    return void 0;
+  }
+  const position = asRecord(record.position);
+  const rotation = asRecord(record.rotation);
+  const scale = asRecord(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")
+  };
+}
+__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 = asRecord(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 = asRecord(values.audioValues.get(sourceEntityId));
+  if (sourceAudio && entityType !== "audio") {
+    const sourceOptions = asRecord(sourceAudio.options) ?? {};
+    objectManagementSystem.createComponentNow(
+      "audio",
+      world,
+      targetEntityId,
+      typeof sourceAudio.path === "string" ? sourceAudio.path : "",
+      sourceOptions,
+      {
+        object: objectRef,
+        listener: objectManagementSystem.getOrCreateAudioListener(),
+        isEditor: objectManagementSystem.isEditorMode()
+      }
+    );
+  }
+  const sourceImageTarget = asRecord(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 = asRecord(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 = asRecord(values.scriptValues.get(sourceEntityId));
+  if (sourceScript) {
+    const entries = Array.isArray(sourceScript.entries) ? sourceScript.entries.map((entry) => asRecord(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) {
+      return;
+    }
+    world.addComponent(
+      targetEntityId,
+      new ScriptComponent(entries)
+    );
+  }
+}
+__name(restorePostCreateComponents, "restorePostCreateComponents");
+
+// core/hydration/animation.ts
+function readAnimationClipName(value) {
+  if (typeof value === "string") {
+    return value;
+  }
+  const record = asRecord(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 = asRecord(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 = asRecord(value);
+  if (!record) {
+    return null;
+  }
+  const nestedValues = asRecord(record.values);
+  if (nestedValues) {
+    return nestedValues;
+  }
+  return record;
+}
+__name(readEnvironmentState, "readEnvironmentState");
+function readPostprocessingState(value) {
+  const record = asRecord(value);
+  if (!record) {
+    return null;
+  }
+  const nestedValues = asRecord(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 = asRecord(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 = asRecord(values.modelValues.get(sourceEntityId));
+  if (sourceModel) {
+    const modelComponent = world.getComponent(targetEntityId, ModelComponent);
+    if (modelComponent && typeof sourceModel.path === "string") {
+      modelComponent.path = sourceModel.path;
+    }
+  }
+  const sourceImage = asRecord(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 = asRecord(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 = asRecord(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 = asRecord(sourceVideo.options);
+      if (videoOptions) {
+        videoComponent.options = {
+          ...videoComponent.options,
+          ...videoOptions
+        };
+      }
+    }
+  }
+  const sourceAudio = asRecord(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 = asRecord(sourceAudio.options);
+      if (audioOptions) {
+        audioComponent.options = {
+          ...audioComponent.options,
+          ...audioOptions
+        };
+      }
+    }
+  }
+  const sourceCamera = asRecord(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 = asRecord(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 = asRecord(values.lightValues.get(sourceEntityId));
+  if (sourceLight) {
+    const lightComponent = world.getComponent(targetEntityId, LightComponent);
+    const sourceValues = asRecord(sourceLight.values);
+    if (lightComponent && sourceValues) {
+      lightComponent.values = {
+        ...lightComponent.values,
+        ...sourceValues
+      };
+    }
+  }
+  const sourceMaterial = asRecord(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 sourceMeshGeometry = asRecord(values.meshGeometryValues.get(sourceEntityId));
+  if (sourceMeshGeometry) {
+    const meshGeometryComponent = world.getComponent(
+      targetEntityId,
+      MeshGeometryComponent
+    );
+    if (meshGeometryComponent) {
+      const parameters = asRecord(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 = asRecord(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 = asRecord(values.physicsValues.get(sourceEntityId));
+  if (sourcePhysics) {
+    const physicsValues = asRecord(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: asRecord(physicsValues.rigidbody) ?? {},
+        collider: asRecord(physicsValues.collider) ?? {}
+      });
+    }
+  }
+  const sourceAnimation = asRecord(values.animationValues.get(sourceEntityId));
+  if (sourceAnimation) {
+    restoreAnimationComponent(
+      world,
+      objectManagementSystem,
+      targetEntityId,
+      sourceAnimation
+    );
+  }
+}
+__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"
+]);
+
+// 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 = asRecord(componentValues.modelValues.get(sourceEntityId));
+    if (typeof model?.path === "string") {
+      payload.path = model.path;
+    }
+  }
+  if (kind === "image") {
+    const image = asRecord(componentValues.imageValues.get(sourceEntityId));
+    if (typeof image?.path === "string") {
+      payload.path = image.path;
+    }
+  }
+  if (kind === "sprite") {
+    const sprite = asRecord(componentValues.spriteValues.get(sourceEntityId));
+    if (typeof sprite?.path === "string") {
+      payload.path = sprite.path;
+    }
+  }
+  if (kind === "video") {
+    const video = asRecord(componentValues.videoValues.get(sourceEntityId));
+    if (typeof video?.path === "string") {
+      payload.path = video.path;
+    }
+    const videoOptions = asRecord(video?.options);
+    if (videoOptions) {
+      payload.options = videoOptions;
+    }
+  }
+  if (kind === "audio") {
+    const audio = asRecord(componentValues.audioValues.get(sourceEntityId));
+    if (typeof audio?.path === "string") {
+      payload.path = audio.path;
+    }
+    const audioOptions = asRecord(audio?.options);
+    if (audioOptions) {
+      payload.options = audioOptions;
+    }
+  }
+  if (kind === "camera") {
+    const camera = asRecord(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 = asRecord(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
+      };
+    }
+  }
+  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 = asRecord(componentValues.cameraValues.get(sourceEntityId));
+    if (cameraValue?.isDefault === true) {
+      return sourceEntityId;
+    }
+  }
+  return firstCameraSourceEntityId;
+}
+__name(resolvePrimaryCameraSourceEntityId, "resolvePrimaryCameraSourceEntityId");
+function applyLocalTransformsAfterHierarchyRestore(world) {
+  const transformEntities = 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) {
+  if (!snapshot || !snapshot.entities.length) {
+    return {
+      restoredCount: 0,
+      selectedEntityId: null
+    };
+  }
+  const entityTypeValues = readByComponent(snapshot.components, "EntityType");
+  const componentValues = buildComponentValueMaps(snapshot);
+  const primaryCameraSourceEntityId = resolvePrimaryCameraSourceEntityId(
+    snapshot,
+    componentValues,
+    entityTypeValues
+  );
+  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 options = asRecord(payload.options);
+      payload.options = {
+        ...options ?? {},
+        isDefault: 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);
+  const selectedEntityId = typeof snapshot.selectedEntityId === "number" ? idMap.get(snapshot.selectedEntityId) ?? null : null;
+  return {
+    restoredCount: idMap.size,
+    selectedEntityId
+  };
+}
+__name(hydrateWorldFromSnapshotDetailed, "hydrateWorldFromSnapshotDetailed");
+function hydrateWorldFromSnapshot(snapshot, world, objectManagementSystem) {
+  return hydrateWorldFromSnapshotDetailed(
+    snapshot,
+    world,
+    objectManagementSystem
+  ).restoredCount;
+}
+__name(hydrateWorldFromSnapshot, "hydrateWorldFromSnapshot");
+
+export { HYDRATABLE_ENTITY_KINDS, World, hydrateWorldFromSnapshot, hydrateWorldFromSnapshotDetailed };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map