@relu-interactives/spatial-ecs 0.5.3 → 0.8.0

package/dist/chunk-G4XJ53LS.js

@@ -0,0 +1,1237 @@
+import { AnimationComponent, AudioComponent, Object3DRef, CameraComponent, MeshGeometryComponent, PhysicsComponent, Environment, EntityType, ImageComponent, ImageTargetAnchor, ImageTarget, LightComponent, MaterialComponent, MeshComponent, ModelComponent, Name, ParentId, Postprocessing, ScriptComponent, ScriptObjectComponent, Selectable, SelectionTransformState, SpriteComponent, TransformComponent, InstancedMeshComponent, InstanceSlotComponent, VideoComponent, XRRigComponent, VRTeleportAreaComponent, XRHandPoseComponent, XRAnchorComponent, BoneAttachmentComponent, IKComponent, NetworkIdentityComponent, NetworkTransformComponent, NetworkedPropsComponent, NetworkSpawnerComponent, XRInteractableComponent, XRInteractorComponent, XRInteractorSideComponent, UIButtonComponent, UIPanelComponent, UISliderComponent, UITextComponent, UIToggleComponent, setModelLoadState } from './chunk-NNDUOQ7O.js';
+import { detectRig, skeletonFromObject3D } from './chunk-GSWC6LLD.js';
+import { __name } from './chunk-XE4OXN2W.js';
+import * as THREE from 'three';
+import { DRACOLoader } from 'three/examples/jsm/loaders/DRACOLoader.js';
+import { GLTFLoader } from 'three/examples/jsm/loaders/GLTFLoader.js';
+import { MeshoptDecoder } from 'three/examples/jsm/libs/meshopt_decoder.module.js';
+import { clone } from 'three/examples/jsm/utils/SkeletonUtils.js';
+
+// core/factories/components/AnimationFactory.ts
+function createAnimationComponent(world, entityId, ...args) {
+  const component = new AnimationComponent(...args);
+  world.addComponent(entityId, component);
+  return component;
+}
+__name(createAnimationComponent, "createAnimationComponent");
+function normalizeDistanceModel(distanceModel) {
+  const normalized = distanceModel.trim().toLowerCase();
+  if (normalized === "linear" || normalized === "exponential") {
+    return normalized;
+  }
+  return "inverse";
+}
+__name(normalizeDistanceModel, "normalizeDistanceModel");
+function createConfiguredAudio(listener, options) {
+  const sound = options.positional ? new THREE.PositionalAudio(listener) : new THREE.Audio(listener);
+  sound.setLoop(options.loop);
+  sound.setVolume(options.volume);
+  sound.setPlaybackRate(options.pitch);
+  if (sound instanceof THREE.PositionalAudio) {
+    sound.setRefDistance(options.refDistance);
+    sound.setDistanceModel(normalizeDistanceModel(options.distanceModel));
+    sound.setRolloffFactor(options.rolloffFactor);
+  }
+  return sound;
+}
+__name(createConfiguredAudio, "createConfiguredAudio");
+function createAudioEditorHelper() {
+  if (typeof document === "undefined") {
+    const geometry = new THREE.EdgesGeometry(
+      new THREE.OctahedronGeometry(0.22, 0)
+    );
+    const material2 = new THREE.LineBasicMaterial({
+      color: "#8bc8ff",
+      transparent: true,
+      opacity: 0.95,
+      depthTest: false
+    });
+    const fallback = new THREE.LineSegments(geometry, material2);
+    fallback.renderOrder = 10;
+    fallback.userData.ecsHelper = true;
+    fallback.visible = false;
+    return fallback;
+  }
+  const size = 96;
+  const canvas = document.createElement("canvas");
+  canvas.width = size;
+  canvas.height = size;
+  const ctx = canvas.getContext("2d");
+  if (!ctx) {
+    return new THREE.Object3D();
+  }
+  ctx.clearRect(0, 0, size, size);
+  ctx.fillStyle = "rgba(27, 35, 52, 0.9)";
+  ctx.beginPath();
+  ctx.arc(size / 2, size / 2, 36, 0, Math.PI * 2);
+  ctx.fill();
+  ctx.strokeStyle = "rgba(137, 202, 255, 0.9)";
+  ctx.lineWidth = 4;
+  ctx.beginPath();
+  ctx.arc(size / 2, size / 2, 36, 0, Math.PI * 2);
+  ctx.stroke();
+  ctx.fillStyle = "#d9ecff";
+  ctx.beginPath();
+  ctx.moveTo(33, 56);
+  ctx.lineTo(43, 56);
+  ctx.lineTo(54, 66);
+  ctx.lineTo(54, 30);
+  ctx.lineTo(43, 40);
+  ctx.lineTo(33, 40);
+  ctx.closePath();
+  ctx.fill();
+  ctx.strokeStyle = "#7fd2ff";
+  ctx.lineWidth = 4;
+  ctx.lineCap = "round";
+  ctx.beginPath();
+  ctx.arc(56, 48, 10, -0.8, 0.8);
+  ctx.stroke();
+  ctx.beginPath();
+  ctx.arc(56, 48, 16, -0.8, 0.8);
+  ctx.stroke();
+  const texture = new THREE.CanvasTexture(canvas);
+  texture.needsUpdate = true;
+  const material = new THREE.SpriteMaterial({
+    map: texture,
+    transparent: true,
+    depthTest: false
+  });
+  const helper = new THREE.Sprite(material);
+  helper.scale.set(0.68, 0.68, 0.68);
+  helper.renderOrder = 10;
+  helper.userData.ecsHelper = true;
+  helper.visible = false;
+  return helper;
+}
+__name(createAudioEditorHelper, "createAudioEditorHelper");
+function createAudioComponent(world, entityId, path = "", options = {}, context) {
+  const component = new AudioComponent(path, options);
+  const anchor = context?.object ?? null;
+  const listener = context?.listener ?? null;
+  if (anchor && listener) {
+    component.object = anchor;
+    const sound = createConfiguredAudio(listener, component.options);
+    if (context?.isEditor) {
+      anchor.add(createAudioEditorHelper());
+    }
+    anchor.add(sound);
+    component.audio = sound;
+  }
+  world.addComponent(entityId, component);
+  return component;
+}
+__name(createAudioComponent, "createAudioComponent");
+function createCameraComponent(world, entityId, payload = {}) {
+  const object = world.getComponent(entityId, Object3DRef)?.object;
+  const objectCamera = object instanceof THREE.Camera ? object : void 0;
+  const component = new CameraComponent({
+    ...payload,
+    camera: payload.camera ?? objectCamera
+  });
+  world.addComponent(entityId, component);
+  return component;
+}
+__name(createCameraComponent, "createCameraComponent");
+
+// core/factories/components/PhysicsFactory.ts
+function deriveColliderFromGeometry(world, entityId) {
+  const meshGeometry = world.getComponent(entityId, MeshGeometryComponent);
+  if (!meshGeometry) {
+    return null;
+  }
+  switch (meshGeometry.kind) {
+    case "plane": {
+      const params = meshGeometry.parameters;
+      return {
+        collider: {
+          shape: "cuboid",
+          size: { x: params.width, y: params.height, z: 0.05 }
+        },
+        // An (effectively) zero-thickness sheet is only physically meaningful
+        // as static geometry — planes are floors/walls, not dynamic bodies.
+        rigidbody: { type: "fixed" }
+      };
+    }
+    case "cube": {
+      const params = meshGeometry.parameters;
+      return {
+        collider: {
+          shape: "cuboid",
+          size: { x: params.width, y: params.height, z: params.depth }
+        }
+      };
+    }
+    case "sphere": {
+      const params = meshGeometry.parameters;
+      return { collider: { shape: "ball", radius: params.radius } };
+    }
+    case "capsule": {
+      const params = meshGeometry.parameters;
+      return {
+        collider: {
+          shape: "capsule",
+          radius: params.radius,
+          height: params.height
+        }
+      };
+    }
+    case "cylinder": {
+      const params = meshGeometry.parameters;
+      return {
+        collider: {
+          shape: "cylinder",
+          radius: params.radius,
+          height: params.height
+        }
+      };
+    }
+    default:
+      return null;
+  }
+}
+__name(deriveColliderFromGeometry, "deriveColliderFromGeometry");
+function createPhysicsComponent(world, entityId, values) {
+  const initial = values ?? deriveColliderFromGeometry(world, entityId) ?? void 0;
+  const component = new PhysicsComponent(initial);
+  world.addComponent(entityId, component);
+  return component;
+}
+__name(createPhysicsComponent, "createPhysicsComponent");
+
+// core/factories/components/EnvironmentFactory.ts
+function createEnvironmentComponent(world, entityId, values) {
+  const component = new Environment(values);
+  world.addComponent(entityId, component);
+  return component;
+}
+__name(createEnvironmentComponent, "createEnvironmentComponent");
+
+// core/factories/components/EntityTypeFactory.ts
+function createEntityTypeComponent(world, entityId, ...args) {
+  const component = new EntityType(...args);
+  world.addComponent(entityId, component);
+  return component;
+}
+__name(createEntityTypeComponent, "createEntityTypeComponent");
+
+// core/factories/components/ImageComponentFactory.ts
+function createImageComponent(world, entityId, ...args) {
+  const component = new ImageComponent(...args);
+  world.addComponent(entityId, component);
+  return component;
+}
+__name(createImageComponent, "createImageComponent");
+
+// core/factories/components/ImageTargetAnchorFactory.ts
+function createImageTargetAnchorComponent(world, entityId, ...args) {
+  const component = new ImageTargetAnchor(...args);
+  world.addComponent(entityId, component);
+  return component;
+}
+__name(createImageTargetAnchorComponent, "createImageTargetAnchorComponent");
+
+// core/factories/components/ImageTargetFactory.ts
+function createImageTargetComponent(world, entityId, ...args) {
+  const component = new ImageTarget(...args);
+  world.addComponent(entityId, component);
+  return component;
+}
+__name(createImageTargetComponent, "createImageTargetComponent");
+
+// core/factories/components/LightFactory.ts
+function createLightComponent(world, entityId, ...args) {
+  const component = new LightComponent(...args);
+  world.addComponent(entityId, component);
+  return component;
+}
+__name(createLightComponent, "createLightComponent");
+
+// core/factories/components/MaterialFactory.ts
+function createMaterialComponent(world, entityId, ...args) {
+  const component = new MaterialComponent(...args);
+  world.addComponent(entityId, component);
+  return component;
+}
+__name(createMaterialComponent, "createMaterialComponent");
+
+// core/factories/components/MeshFactory.ts
+function createMeshComponent(world, entityId, ...args) {
+  const component = new MeshComponent(...args);
+  world.addComponent(entityId, component);
+  return component;
+}
+__name(createMeshComponent, "createMeshComponent");
+
+// core/factories/components/MeshGeometryFactory.ts
+function createMeshGeometryComponent(world, entityId, ...args) {
+  const component = new MeshGeometryComponent(...args);
+  world.addComponent(entityId, component);
+  return component;
+}
+__name(createMeshGeometryComponent, "createMeshGeometryComponent");
+
+// core/factories/components/ModelFactory.ts
+function createModelComponent(world, entityId, ...args) {
+  const component = new ModelComponent(...args);
+  world.addComponent(entityId, component);
+  return component;
+}
+__name(createModelComponent, "createModelComponent");
+
+// core/factories/components/NameFactory.ts
+function createNameComponent(world, entityId, ...args) {
+  const component = new Name(...args);
+  world.addComponent(entityId, component);
+  return component;
+}
+__name(createNameComponent, "createNameComponent");
+
+// core/factories/components/Object3DRefFactory.ts
+function createObject3DRefComponent(world, entityId, ...args) {
+  const component = new Object3DRef(...args);
+  world.addComponent(entityId, component);
+  return component;
+}
+__name(createObject3DRefComponent, "createObject3DRefComponent");
+
+// core/factories/components/ParentIdFactory.ts
+function createParentIdComponent(world, entityId, ...args) {
+  const component = new ParentId(...args);
+  world.addComponent(entityId, component);
+  return component;
+}
+__name(createParentIdComponent, "createParentIdComponent");
+
+// core/factories/components/PostprocessingFactory.ts
+function createPostprocessingComponent(world, entityId, values) {
+  const component = new Postprocessing(values);
+  world.addComponent(entityId, component);
+  return component;
+}
+__name(createPostprocessingComponent, "createPostprocessingComponent");
+
+// core/factories/components/ScriptComponentFactory.ts
+function createScriptComponent(world, entityId, payload = {}) {
+  const entries = Array.isArray(payload.entries) ? payload.entries.map((entry) => ({
+    entityId,
+    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
+  })) : [];
+  const component = new ScriptComponent(entries);
+  world.addComponent(entityId, component);
+  return component;
+}
+__name(createScriptComponent, "createScriptComponent");
+
+// core/factories/components/ScriptObjectComponentFactory.ts
+function createScriptObjectComponent(world, entityId, payload = {}) {
+  const component = new ScriptObjectComponent(payload);
+  world.addComponent(entityId, component);
+  return component;
+}
+__name(createScriptObjectComponent, "createScriptObjectComponent");
+
+// core/factories/components/SelectableFactory.ts
+function createSelectableComponent(world, entityId, ...args) {
+  const component = new Selectable(...args);
+  world.addComponent(entityId, component);
+  return component;
+}
+__name(createSelectableComponent, "createSelectableComponent");
+
+// core/factories/components/SelectionTransformStateFactory.ts
+function createSelectionTransformStateComponent(world, entityId, ...args) {
+  const component = new SelectionTransformState(...args);
+  world.addComponent(entityId, component);
+  return component;
+}
+__name(createSelectionTransformStateComponent, "createSelectionTransformStateComponent");
+
+// core/factories/components/SpriteFactory.ts
+function createSpriteComponent(world, entityId, ...args) {
+  const component = new SpriteComponent(...args);
+  world.addComponent(entityId, component);
+  return component;
+}
+__name(createSpriteComponent, "createSpriteComponent");
+
+// core/factories/components/TransformFactory.ts
+function createTransformComponent(world, entityId, ...args) {
+  const component = new TransformComponent(...args);
+  world.addComponent(entityId, component);
+  return component;
+}
+__name(createTransformComponent, "createTransformComponent");
+
+// core/factories/components/InstancedMeshComponentFactory.ts
+function createInstancedMeshComponent(world, entityId, meshKind, meshParameters, options) {
+  const component = new InstancedMeshComponent(meshKind, meshParameters, options);
+  world.addComponent(entityId, component);
+  return component;
+}
+__name(createInstancedMeshComponent, "createInstancedMeshComponent");
+
+// core/factories/components/InstanceSlotComponentFactory.ts
+function createInstanceSlotComponent(world, entityId, groupEntityId, slotIndex) {
+  const component = new InstanceSlotComponent(groupEntityId, slotIndex);
+  world.addComponent(entityId, component);
+  return component;
+}
+__name(createInstanceSlotComponent, "createInstanceSlotComponent");
+
+// core/factories/components/VideoFactory.ts
+function createVideoComponent(world, entityId, ...args) {
+  const component = new VideoComponent(...args);
+  world.addComponent(entityId, component);
+  return component;
+}
+__name(createVideoComponent, "createVideoComponent");
+
+// core/factories/components/XRRigFactory.ts
+function createXRRigComponent(world, entityId, ...args) {
+  const component = new XRRigComponent(...args);
+  world.addComponent(entityId, component);
+  return component;
+}
+__name(createXRRigComponent, "createXRRigComponent");
+
+// core/factories/components/VRTeleportAreaFactory.ts
+function createVRTeleportAreaComponent(world, entityId, ...args) {
+  const component = new VRTeleportAreaComponent(...args);
+  world.addComponent(entityId, component);
+  return component;
+}
+__name(createVRTeleportAreaComponent, "createVRTeleportAreaComponent");
+
+// core/factories/components/XRHandPoseFactory.ts
+function createXRHandPoseComponent(world, entityId, ...args) {
+  const component = new XRHandPoseComponent(...args);
+  world.addComponent(entityId, component);
+  return component;
+}
+__name(createXRHandPoseComponent, "createXRHandPoseComponent");
+
+// core/factories/components/XRAnchorFactory.ts
+function createXRAnchorComponent(world, entityId, ...args) {
+  const component = new XRAnchorComponent(...args);
+  world.addComponent(entityId, component);
+  return component;
+}
+__name(createXRAnchorComponent, "createXRAnchorComponent");
+
+// core/factories/components/BoneAttachmentFactory.ts
+function createBoneAttachmentComponent(world, entityId, ...args) {
+  const component = new BoneAttachmentComponent(...args);
+  world.addComponent(entityId, component);
+  return component;
+}
+__name(createBoneAttachmentComponent, "createBoneAttachmentComponent");
+
+// core/factories/components/IKFactory.ts
+function createIKComponent(world, entityId, ...args) {
+  const component = new IKComponent(...args);
+  world.addComponent(entityId, component);
+  return component;
+}
+__name(createIKComponent, "createIKComponent");
+
+// core/factories/components/NetworkFactory.ts
+function createNetworkIdentityComponent(world, entityId) {
+  const component = new NetworkIdentityComponent();
+  world.addComponent(entityId, component);
+  return component;
+}
+__name(createNetworkIdentityComponent, "createNetworkIdentityComponent");
+function createNetworkTransformComponent(world, entityId, ...args) {
+  const component = new NetworkTransformComponent(...args);
+  world.addComponent(entityId, component);
+  return component;
+}
+__name(createNetworkTransformComponent, "createNetworkTransformComponent");
+function createNetworkedPropsComponent(world, entityId, ...args) {
+  const component = new NetworkedPropsComponent(...args);
+  world.addComponent(entityId, component);
+  return component;
+}
+__name(createNetworkedPropsComponent, "createNetworkedPropsComponent");
+function createNetworkSpawnerComponent(world, entityId, ...args) {
+  const component = new NetworkSpawnerComponent(...args);
+  world.addComponent(entityId, component);
+  return component;
+}
+__name(createNetworkSpawnerComponent, "createNetworkSpawnerComponent");
+
+// core/factories/components/XRInteractableFactory.ts
+function createXRInteractableComponent(world, entityId, ...args) {
+  const component = new XRInteractableComponent(...args);
+  world.addComponent(entityId, component);
+  return component;
+}
+__name(createXRInteractableComponent, "createXRInteractableComponent");
+
+// core/factories/components/XRInteractorFactory.ts
+function createXRInteractorComponent(world, entityId, ...args) {
+  const component = new XRInteractorComponent(...args);
+  world.addComponent(entityId, component);
+  return component;
+}
+__name(createXRInteractorComponent, "createXRInteractorComponent");
+
+// core/factories/components/XRInteractorSideFactory.ts
+function createXRInteractorSideComponent(world, entityId, ...args) {
+  const component = new XRInteractorSideComponent(...args);
+  world.addComponent(entityId, component);
+  return component;
+}
+__name(createXRInteractorSideComponent, "createXRInteractorSideComponent");
+
+// core/factories/components/UIButtonComponentFactory.ts
+function createUIButtonComponent(world, entityId, ...args) {
+  const component = new UIButtonComponent(...args);
+  world.addComponent(entityId, component);
+  return component;
+}
+__name(createUIButtonComponent, "createUIButtonComponent");
+
+// core/factories/components/UIPanelComponentFactory.ts
+function createUIPanelComponent(world, entityId, ...args) {
+  const component = new UIPanelComponent(...args);
+  world.addComponent(entityId, component);
+  return component;
+}
+__name(createUIPanelComponent, "createUIPanelComponent");
+
+// core/factories/components/UISliderComponentFactory.ts
+function createUISliderComponent(world, entityId, ...args) {
+  const component = new UISliderComponent(...args);
+  world.addComponent(entityId, component);
+  return component;
+}
+__name(createUISliderComponent, "createUISliderComponent");
+
+// core/factories/components/UITextComponentFactory.ts
+function createUITextComponent(world, entityId, ...args) {
+  const component = new UITextComponent(...args);
+  world.addComponent(entityId, component);
+  return component;
+}
+__name(createUITextComponent, "createUITextComponent");
+
+// core/factories/components/UIToggleComponentFactory.ts
+function createUIToggleComponent(world, entityId, ...args) {
+  const component = new UIToggleComponent(...args);
+  world.addComponent(entityId, component);
+  return component;
+}
+__name(createUIToggleComponent, "createUIToggleComponent");
+function collectBones(root) {
+  const bones = /* @__PURE__ */ new Set();
+  root.traverse((o) => {
+    if (o.isBone) bones.add(o);
+    const skinned = o;
+    if (skinned.isSkinnedMesh && skinned.skeleton) {
+      for (const b of skinned.skeleton.bones) bones.add(b);
+    }
+  });
+  return bones;
+}
+__name(collectBones, "collectBones");
+function humanoidNames(root) {
+  try {
+    return detectRig(skeletonFromObject3D(root)).byName;
+  } catch {
+    return /* @__PURE__ */ new Map();
+  }
+}
+__name(humanoidNames, "humanoidNames");
+function listModelBones(root) {
+  const bones = collectBones(root);
+  const humanoid = humanoidNames(root);
+  const out = [];
+  const visit = /* @__PURE__ */ __name((o, parent, depth) => {
+    const isBone = bones.has(o);
+    if (isBone) {
+      out.push({ name: o.name, humanoid: humanoid.get(o.name) ?? null, parent: parent?.name ?? null, depth });
+    }
+    for (const c of o.children) visit(c, isBone ? o : parent, isBone ? depth + 1 : depth);
+  }, "visit");
+  visit(root, null, 0);
+  return out;
+}
+__name(listModelBones, "listModelBones");
+function findModelBone(root, ref) {
+  const bones = collectBones(root);
+  const byName = /* @__PURE__ */ new Map();
+  for (const b of bones) if (!byName.has(b.name)) byName.set(b.name, b);
+  const name = ref.bone ?? "";
+  if (name) {
+    const hit = byName.get(name) ?? byName.get(THREE.PropertyBinding.sanitizeNodeName(name));
+    if (hit) return hit;
+  }
+  if (ref.humanoid) {
+    for (const [node, human] of humanoidNames(root)) {
+      if (human === ref.humanoid) return byName.get(node) ?? root.getObjectByName(node) ?? null;
+    }
+  }
+  return null;
+}
+__name(findModelBone, "findModelBone");
+
+// core/utils/dracoDecoderPath.ts
+var LOCAL_DRACO_DECODER_RELATIVE_PATH = "./assets/draco/";
+var DRACO_DECODER_CDN_PATH = "https://www.gstatic.com/draco/versioned/decoders/1.5.7/";
+var dracoDecoderPathOverride = null;
+function setDracoDecoderPath(path) {
+  dracoDecoderPathOverride = path;
+}
+__name(setDracoDecoderPath, "setDracoDecoderPath");
+function isBlockedBrowserFileUrl(url) {
+  return url.startsWith("file://");
+}
+__name(isBlockedBrowserFileUrl, "isBlockedBrowserFileUrl");
+function resolveDracoDecoderPath() {
+  if (dracoDecoderPathOverride) {
+    return dracoDecoderPathOverride;
+  }
+  try {
+    const resolvedPath = new URL(
+      LOCAL_DRACO_DECODER_RELATIVE_PATH,
+      import.meta.url
+    ).toString();
+    if (isBlockedBrowserFileUrl(resolvedPath)) {
+      return DRACO_DECODER_CDN_PATH;
+    }
+    return resolvedPath;
+  } catch {
+    return DRACO_DECODER_CDN_PATH;
+  }
+}
+__name(resolveDracoDecoderPath, "resolveDracoDecoderPath");
+function createGLTFLoader() {
+  const loader = new GLTFLoader();
+  try {
+    const dracoLoader = new DRACOLoader();
+    dracoLoader.setDecoderPath(resolveDracoDecoderPath());
+    loader.setDRACOLoader(dracoLoader);
+  } catch (error) {
+    console.warn("DRACOLoader could not be configured. Loading non-Draco models only.", error);
+  }
+  loader.setMeshoptDecoder(MeshoptDecoder);
+  return loader;
+}
+__name(createGLTFLoader, "createGLTFLoader");
+var SHARED_MODEL_RESOURCE_FLAG = "spatialEcsSharedModelResource";
+var modelCache = /* @__PURE__ */ new Map();
+function markSharedResources(root) {
+  root.traverse((child) => {
+    if (!(child instanceof THREE.Mesh)) {
+      return;
+    }
+    if (child.geometry) {
+      child.geometry.userData[SHARED_MODEL_RESOURCE_FLAG] = true;
+    }
+    const materials = Array.isArray(child.material) ? child.material : [child.material];
+    for (const material of materials) {
+      if (material) {
+        material.userData[SHARED_MODEL_RESOURCE_FLAG] = true;
+      }
+    }
+  });
+}
+__name(markSharedResources, "markSharedResources");
+function loadSharedGltf(url, load) {
+  let pending = modelCache.get(url);
+  if (!pending) {
+    pending = load().then((gltf) => {
+      markSharedResources(gltf.scene);
+      return gltf;
+    });
+    pending.catch(() => {
+      modelCache.delete(url);
+    });
+    modelCache.set(url, pending);
+  }
+  return pending;
+}
+__name(loadSharedGltf, "loadSharedGltf");
+function cloneModelScene(scene) {
+  return clone(scene);
+}
+__name(cloneModelScene, "cloneModelScene");
+function clearModelCache(url) {
+  if (typeof url === "string") {
+    modelCache.delete(url);
+    return;
+  }
+  modelCache.clear();
+}
+__name(clearModelCache, "clearModelCache");
+
+// core/factories/objects/shared.ts
+function createBaseEntity(world, object, options) {
+  const entityId = world.createEntity();
+  object.userData.entityId = entityId;
+  const transform = createTransform(options.transformInput);
+  applyTransform(object, transform);
+  world.addComponent(entityId, transform);
+  createObject3DRefComponent(world, entityId, object);
+  createNameComponent(world, entityId, options.label);
+  createEntityTypeComponent(world, entityId, options.entityType);
+  createParentIdComponent(world, entityId, options.parentId ?? null);
+  createSelectableComponent(world, entityId, true);
+  return entityId;
+}
+__name(createBaseEntity, "createBaseEntity");
+
+// core/factories/objects/ModelFactory.ts
+function getModelFileName(path) {
+  const segments = path.split(/[\\/]/).filter(Boolean);
+  return segments[segments.length - 1] ?? "";
+}
+__name(getModelFileName, "getModelFileName");
+function createModelLoader() {
+  return createGLTFLoader();
+}
+__name(createModelLoader, "createModelLoader");
+function createModel({
+  world,
+  scene,
+  payload,
+  isEditor
+}) {
+  const anchor = new THREE.Object3D();
+  const modelPath = payload.path ?? "";
+  const entityId = createBaseEntity(world, anchor, {
+    label: payload.name ?? "Model",
+    entityType: "model",
+    transformInput: payload.transform
+  });
+  const model = createModelComponent(world, entityId, modelPath);
+  createMeshGeometryComponent(world, entityId, "model", anchor, {}, {
+    modelName: getModelFileName(modelPath),
+    castShadow: false,
+    receiveShadow: false
+  });
+  model.object = anchor;
+  scene.add(anchor);
+  if (!modelPath) {
+    return entityId;
+  }
+  setModelLoadState(model, "loading");
+  loadModelInto({ world, entityId, anchor, modelPath, isEditor: Boolean(isEditor) });
+  return entityId;
+}
+__name(createModel, "createModel");
+function loadModelInto({
+  world,
+  entityId,
+  anchor,
+  modelPath,
+  isEditor
+}) {
+  const model = world.getComponent(entityId, ModelComponent);
+  const meshGeometry = world.getComponent(entityId, MeshGeometryComponent);
+  if (!model) return;
+  const attachLoadedModel = /* @__PURE__ */ __name((gltf, object) => {
+    if (!world.hasEntity(entityId) || world.getComponent(entityId, ModelComponent) !== model) {
+      return;
+    }
+    object.userData.entityId = entityId;
+    object.traverse((child) => {
+      child.userData.entityId = entityId;
+    });
+    anchor.add(object);
+    model.object = object;
+    if (meshGeometry) meshGeometry.object = object;
+    if (gltf.animations.length > 0) {
+      let animation = world.getComponent(entityId, AnimationComponent);
+      if (!animation) {
+        animation = createAnimationComponent(world, entityId, {
+          clips: gltf.animations,
+          externalClipSources: [],
+          paused: false,
+          reverse: false,
+          timeScale: 1,
+          crossFadeDuration: 0
+        });
+      }
+      animation.setModelClips(gltf.animations);
+    }
+    setModelLoadState(model, "loaded");
+  }, "attachLoadedModel");
+  const onLoadError = /* @__PURE__ */ __name((error) => {
+    const message = error instanceof Error && error.message ? error.message : typeof error === "string" && error ? error : `Failed to load model: ${modelPath}`;
+    setModelLoadState(model, "error", message);
+    console.error(`Failed to load model: ${modelPath}`, error);
+  }, "onLoadError");
+  if (isEditor) {
+    createModelLoader().load(
+      modelPath,
+      (gltf) => attachLoadedModel(gltf, gltf.scene),
+      void 0,
+      onLoadError
+    );
+  } else {
+    loadSharedGltf(
+      modelPath,
+      () => new Promise((resolve, reject) => {
+        createModelLoader().load(modelPath, resolve, void 0, reject);
+      })
+    ).then((gltf) => attachLoadedModel(gltf, cloneModelScene(gltf.scene))).catch(onLoadError);
+  }
+}
+__name(loadModelInto, "loadModelInto");
+function reloadModelEntity(world, entityId, isEditor) {
+  const model = world.getComponent(entityId, ModelComponent);
+  const anchor = world.getComponent(entityId, Object3DRef)?.object;
+  if (!model || !anchor || !model.path) return false;
+  const old = model.object;
+  if (old && old !== anchor) {
+    old.removeFromParent();
+    old.traverse((child) => {
+      const mesh = child;
+      if (mesh.geometry && !mesh.geometry.userData?.[SHARED_MODEL_RESOURCE_FLAG]) mesh.geometry.dispose();
+      const mats = Array.isArray(mesh.material) ? mesh.material : mesh.material ? [mesh.material] : [];
+      for (const m of mats) if (!m.userData?.[SHARED_MODEL_RESOURCE_FLAG]) m.dispose();
+    });
+  }
+  model.object = anchor;
+  setModelLoadState(model, "loading");
+  loadModelInto({ world, entityId, anchor, modelPath: model.path, isEditor });
+  return true;
+}
+__name(reloadModelEntity, "reloadModelEntity");
+
+// core/systems/ObjectManagementSystem.ts
+var BONE_SOCKET_FLAG = "__reluBoneSocket";
+var _boneScale = new THREE.Vector3();
+var _anchorScale = new THREE.Vector3();
+function createTransform(input) {
+  return new TransformComponent(input);
+}
+__name(createTransform, "createTransform");
+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");
+var _ObjectManagementSystem = class _ObjectManagementSystem {
+  constructor(scene, camera, isEditor = false) {
+    this.registry = /* @__PURE__ */ new Map();
+    this.componentRegistry = /* @__PURE__ */ new Map();
+    this.createQueue = [];
+    this.boneSockets = /* @__PURE__ */ new Map();
+    /** Attachments whose bone wasn't found in a given model (skip re-searching every frame). */
+    this.boneMisses = /* @__PURE__ */ new Map();
+    this.scene = scene;
+    this.camera = camera;
+    this.isEditor = isEditor;
+  }
+  register(kind, factory) {
+    this.registry.set(kind, factory);
+  }
+  registerComponentFactory(kind, factory) {
+    this.componentRegistry.set(kind, factory);
+  }
+  getOrCreateAudioListener() {
+    const existing = this.camera.userData.ecsAudioListener;
+    if (existing instanceof THREE.AudioListener) {
+      return existing;
+    }
+    const listener = new THREE.AudioListener();
+    this.camera.add(listener);
+    this.camera.userData.ecsAudioListener = listener;
+    return listener;
+  }
+  isEditorMode() {
+    return this.isEditor;
+  }
+  getComponentFactory(kind) {
+    return this.componentRegistry.get(kind) ?? null;
+  }
+  createComponentNow(kind, world, entityId, ...args) {
+    const factory = this.componentRegistry.get(kind);
+    if (!factory) {
+      throw new Error(`Unknown component kind: ${kind}`);
+    }
+    return factory(world, entityId, ...args);
+  }
+  requestCreate(kind, payload = {}, onCreated) {
+    this.createQueue.push({ kind, payload, onCreated });
+  }
+  createNow(kind, world, payload = {}) {
+    const factory = this.registry.get(kind);
+    if (!factory) {
+      throw new Error(`Unknown object kind: ${kind}`);
+    }
+    const entityId = factory({
+      world,
+      scene: this.scene,
+      camera: this.camera,
+      payload,
+      isEditor: this.isEditor
+    });
+    const object = world.getComponent(entityId, Object3DRef)?.object;
+    if (object) {
+      object.userData.ecsKind = kind;
+    }
+    if (payload.parentId !== void 0) {
+      world.addComponent(entityId, new ParentId(payload.parentId));
+    }
+    return entityId;
+  }
+  /**
+   * Removes an entity from the ECS world and its associated `Object3D` from the
+   * THREE.js scene graph.
+   *
+   * @param world - The world the entity belongs to.
+   * @param entityId - The entity to remove.
+   * @param dispose - When `true`, traverses the entity's `Object3D` subtree and
+   *   calls `.dispose()` on every `BufferGeometry` and `Material` found. Pass
+   *   `true` when the entity will not be reused and you want to free GPU memory
+   *   immediately (e.g. dynamically spawned objects). Defaults to `false`.
+   * @returns `true` if the entity existed and was removed; `false` if the entity
+   *   was not found.
+   *
+   * @example
+   * ```ts
+   * // Remove from scene, keep GPU resources (safe if geometry is shared)
+   * objects.deleteEntity(world, entityId);
+   *
+   * // Remove from scene and free GPU memory (use for one-off spawned objects)
+   * objects.deleteEntity(world, entityId, true);
+   * ```
+   */
+  deleteEntity(world, entityId, dispose = false) {
+    if (!world.hasEntity(entityId)) {
+      return false;
+    }
+    const object3d = world.getComponent(entityId, Object3DRef)?.object;
+    if (object3d?.parent) {
+      object3d.parent.remove(object3d);
+    }
+    if (dispose && object3d) {
+      object3d.traverse((child) => {
+        if (child instanceof THREE.Mesh) {
+          if (!child.geometry?.userData?.[SHARED_MODEL_RESOURCE_FLAG]) {
+            child.geometry?.dispose();
+          }
+          const materials = Array.isArray(child.material) ? child.material : [child.material];
+          for (const mat of materials) {
+            if (mat && !mat.userData?.[SHARED_MODEL_RESOURCE_FLAG]) {
+              mat.dispose();
+            }
+          }
+        }
+      });
+    }
+    world.destroyEntity(entityId);
+    return true;
+  }
+  setParent(world, entityId, parentId, options) {
+    if (!world.hasEntity(entityId)) {
+      return false;
+    }
+    if (parentId !== null && !world.hasEntity(parentId)) {
+      return false;
+    }
+    if (parentId === entityId) {
+      return false;
+    }
+    let ancestor = parentId;
+    while (ancestor !== null) {
+      if (ancestor === entityId) {
+        return false;
+      }
+      ancestor = world.getComponent(ancestor, ParentId)?.value ?? null;
+    }
+    const parentComponent = world.getComponent(entityId, ParentId);
+    if (parentComponent) {
+      if (parentComponent.value === parentId) {
+        return false;
+      }
+      parentComponent.value = parentId;
+    } else {
+      world.addComponent(entityId, new ParentId(parentId));
+    }
+    if (world.getComponent(entityId, BoneAttachmentComponent)) {
+      world.removeComponent(entityId, BoneAttachmentComponent);
+    }
+    const preserveWorldTransform = options?.preserveWorldTransform ?? true;
+    if (preserveWorldTransform) {
+      const object = world.getComponent(entityId, Object3DRef)?.object;
+      const parentObject = parentId !== null ? world.getComponent(parentId, Object3DRef)?.object ?? null : null;
+      if (object) {
+        this.scene.updateMatrixWorld(true);
+        if (parentObject && parentObject !== object) {
+          parentObject.attach(object);
+        } else {
+          this.scene.attach(object);
+        }
+        object.updateMatrixWorld(true);
+        this.syncTransformComponentFromObject(world, entityId, object);
+      }
+    }
+    this.reconcileSceneFromWorld(world);
+    return true;
+  }
+  syncTransformComponentFromObject(world, entityId, object) {
+    const transform = world.getComponent(entityId, TransformComponent);
+    if (!transform) {
+      return;
+    }
+    transform.position.x = object.position.x;
+    transform.position.y = object.position.y;
+    transform.position.z = object.position.z;
+    transform.rotation.x = object.rotation.x;
+    transform.rotation.y = object.rotation.y;
+    transform.rotation.z = object.rotation.z;
+    transform.scale.x = object.scale.x;
+    transform.scale.y = object.scale.y;
+    transform.scale.z = object.scale.z;
+  }
+  reconcileSceneFromWorld(world) {
+    const worldObjects = /* @__PURE__ */ new Map();
+    const entityIds = world.query(Object3DRef);
+    for (const entityId of entityIds) {
+      const object = world.getComponent(entityId, Object3DRef)?.object;
+      if (!object) {
+        continue;
+      }
+      worldObjects.set(entityId, object);
+    }
+    for (const child of [...this.scene.children]) {
+      const entityId = child.userData?.entityId;
+      if (typeof entityId === "number" && !world.hasEntity(entityId)) {
+        this.scene.remove(child);
+      }
+    }
+    for (const entityId of [...this.boneSockets.keys()]) {
+      if (!world.hasEntity(entityId)) this.dropBoneSocket(entityId);
+    }
+    for (const [entityId, object] of worldObjects.entries()) {
+      const parentEntityId = world.getComponent(entityId, ParentId)?.value;
+      const parentObject = typeof parentEntityId === "number" ? worldObjects.get(parentEntityId) : void 0;
+      const expectedParent = this.resolveBoneSocket(world, entityId, typeof parentEntityId === "number" ? parentEntityId : null) ?? parentObject;
+      if (expectedParent && expectedParent !== object) {
+        if (object.parent !== expectedParent) {
+          expectedParent.add(object);
+          object.updateMatrixWorld(true);
+        }
+        continue;
+      }
+      if (object.parent !== this.scene) {
+        this.scene.add(object);
+        object.updateMatrixWorld(true);
+      }
+    }
+  }
+  dropBoneSocket(entityId) {
+    const s = this.boneSockets.get(entityId);
+    if (!s) return;
+    s.socket.removeFromParent();
+    this.boneSockets.delete(entityId);
+  }
+  /**
+   * The socket an attached entity hangs under, or `null` (not attached, the
+   * parent's model not loaded yet, or no such bone — the entity then sits
+   * under its parent as an ordinary child).
+   */
+  resolveBoneSocket(world, entityId, parentEntityId) {
+    const attachment = world.getComponent(entityId, BoneAttachmentComponent);
+    if (!attachment) {
+      if (this.boneSockets.has(entityId)) this.dropBoneSocket(entityId);
+      this.boneMisses.delete(entityId);
+      return null;
+    }
+    const root = attachment.enabled && parentEntityId !== null ? world.getComponent(parentEntityId, ModelComponent)?.object ?? null : null;
+    if (!root) {
+      this.dropBoneSocket(entityId);
+      return null;
+    }
+    const key = `${attachment.bone}|${attachment.humanoid ?? ""}|${attachment.compensateScale}`;
+    const current = this.boneSockets.get(entityId);
+    if (current && current.modelUuid === root.uuid && current.key === key && current.socket.parent === current.bone) {
+      this.fitSocketScale(world, current, parentEntityId, attachment.compensateScale);
+      return current.socket;
+    }
+    this.dropBoneSocket(entityId);
+    const missKey = `${root.uuid}|${key}`;
+    if (this.boneMisses.get(entityId) === missKey) return null;
+    const bone = findModelBone(root, attachment);
+    if (!bone) {
+      this.boneMisses.set(entityId, missKey);
+      return null;
+    }
+    this.boneMisses.delete(entityId);
+    const socket = new THREE.Object3D();
+    socket.name = `socket:${bone.name}`;
+    socket.userData[BONE_SOCKET_FLAG] = entityId;
+    bone.add(socket);
+    const s = { bone, socket, modelUuid: root.uuid, key };
+    this.boneSockets.set(entityId, s);
+    this.fitSocketScale(world, s, parentEntityId, attachment.compensateScale);
+    return socket;
+  }
+  /**
+   * Cancel the rig's own scale between the character and the bone (a
+   * centimetre armature under a 0.01 node), so offsets are in the character's
+   * units and the object keeps its size; the character entity's own scale
+   * still applies, as it does to any child.
+   */
+  fitSocketScale(world, s, parentEntityId, compensate) {
+    if (!compensate) {
+      s.socket.scale.set(1, 1, 1);
+      return;
+    }
+    const anchor = parentEntityId !== null ? world.getComponent(parentEntityId, Object3DRef)?.object : null;
+    s.bone.updateWorldMatrix(true, false);
+    _boneScale.setFromMatrixScale(s.bone.matrixWorld);
+    if (anchor) _anchorScale.setFromMatrixScale(anchor.matrixWorld);
+    else _anchorScale.set(1, 1, 1);
+    const safe = /* @__PURE__ */ __name((v) => Math.abs(v) < 1e-9 ? 1 : v, "safe");
+    s.socket.scale.set(
+      _anchorScale.x / safe(_boneScale.x),
+      _anchorScale.y / safe(_boneScale.y),
+      _anchorScale.z / safe(_boneScale.z)
+    );
+  }
+  /**
+   * Load a model entity's file again and swap it in (the file was rewritten);
+   * the entity, its components and children stay, attachments re-home.
+   */
+  reloadModel(world, entityId) {
+    return reloadModelEntity(world, entityId, this.isEditor);
+  }
+  /** Reload every model entity whose path `matches` (returns how many). */
+  reloadModelsAt(world, matches) {
+    let n = 0;
+    for (const id of world.query(ModelComponent)) {
+      const path = world.getComponent(id, ModelComponent)?.path ?? "";
+      if (path && matches(path) && this.reloadModel(world, id)) n++;
+    }
+    return n;
+  }
+  /** The bones of an entity's loaded model (empty until it loads, or for a model without a skeleton). */
+  listModelBones(world, entityId) {
+    const root = world.getComponent(entityId, ModelComponent)?.object;
+    return root ? listModelBones(root) : [];
+  }
+  /** The socket object an attached entity currently hangs under, if resolved. */
+  getBoneSocket(entityId) {
+    return this.boneSockets.get(entityId)?.socket ?? null;
+  }
+  /**
+   * Fix `entityId` to a bone of `parentEntityId`'s model (making it the
+   * parent if it isn't). With `preserveWorldTransform` (default) it stays
+   * where it is and its Transform becomes the offset from the bone; without,
+   * it snaps onto the bone (zero offset). Returns whether the bone was found
+   * (when the model is still loading, the attachment is stored and resolves
+   * once it loads, without preserving the pose).
+   */
+  attachToBone(world, entityId, parentEntityId, ref, options) {
+    if (!world.hasEntity(entityId) || !world.hasEntity(parentEntityId) || entityId === parentEntityId) {
+      return { ok: false, resolved: false, bone: null };
+    }
+    for (let a = parentEntityId; a !== null; a = world.getComponent(a, ParentId)?.value ?? null) {
+      if (a === entityId) return { ok: false, resolved: false, bone: null };
+    }
+    const object = world.getComponent(entityId, Object3DRef)?.object ?? null;
+    this.scene.updateMatrixWorld(true);
+    const worldMatrix = object ? object.matrixWorld.clone() : null;
+    const bones = this.listModelBones(world, parentEntityId);
+    let bone = ref.bone ?? "";
+    let humanoid = ref.humanoid ?? null;
+    const info = bones.find((b) => bone ? b.name === bone : b.humanoid === humanoid);
+    if (info) {
+      bone = info.name;
+      humanoid = info.humanoid ?? humanoid;
+    }
+    const parent = world.getComponent(entityId, ParentId);
+    if (parent) parent.value = parentEntityId;
+    else world.addComponent(entityId, new ParentId(parentEntityId));
+    let attachment = world.getComponent(entityId, BoneAttachmentComponent);
+    if (!attachment) {
+      attachment = new BoneAttachmentComponent();
+      world.addComponent(entityId, attachment);
+    }
+    attachment.bone = bone;
+    attachment.humanoid = humanoid;
+    attachment.compensateScale = options?.compensateScale ?? true;
+    attachment.enabled = true;
+    this.boneMisses.delete(entityId);
+    this.reconcileSceneFromWorld(world);
+    const socket = this.getBoneSocket(entityId);
+    if (object && socket) {
+      if (options?.preserveWorldTransform ?? true) {
+        socket.updateWorldMatrix(true, false);
+        const local = socket.matrixWorld.clone().invert().multiply(worldMatrix);
+        local.decompose(object.position, object.quaternion, object.scale);
+      } else {
+        object.position.set(0, 0, 0);
+        object.quaternion.identity();
+        object.scale.set(1, 1, 1);
+      }
+      object.updateMatrixWorld(true);
+      this.syncTransformComponentFromObject(world, entityId, object);
+    }
+    return { ok: true, resolved: Boolean(socket), bone: bone || humanoid };
+  }
+  /**
+   * Release a bone attachment. The entity stays a child of the character
+   * (or moves to the root with `toRoot`), and by default keeps its place in
+   * the world.
+   */
+  detachFromBone(world, entityId, options) {
+    if (!world.getComponent(entityId, BoneAttachmentComponent)) return false;
+    const object = world.getComponent(entityId, Object3DRef)?.object ?? null;
+    this.scene.updateMatrixWorld(true);
+    const worldMatrix = object ? object.matrixWorld.clone() : null;
+    world.removeComponent(entityId, BoneAttachmentComponent);
+    this.boneMisses.delete(entityId);
+    if (options?.toRoot) {
+      const parent = world.getComponent(entityId, ParentId);
+      if (parent) parent.value = null;
+    }
+    const parentId = world.getComponent(entityId, ParentId)?.value ?? null;
+    const home = (parentId !== null ? world.getComponent(parentId, Object3DRef)?.object : null) ?? this.scene;
+    this.dropBoneSocket(entityId);
+    if (object) {
+      home.add(object);
+      if (worldMatrix && (options?.preserveWorldTransform ?? true)) {
+        home.updateWorldMatrix(true, false);
+        home.matrixWorld.clone().invert().multiply(worldMatrix).decompose(object.position, object.quaternion, object.scale);
+      }
+      object.updateMatrixWorld(true);
+      this.syncTransformComponentFromObject(world, entityId, object);
+    }
+    this.reconcileSceneFromWorld(world);
+    return true;
+  }
+  update(world) {
+    for (const request of this.createQueue.splice(0)) {
+      const entityId = this.createNow(request.kind, world, request.payload);
+      request.onCreated?.(entityId);
+    }
+    this.reconcileSceneFromWorld(world);
+  }
+};
+__name(_ObjectManagementSystem, "ObjectManagementSystem");
+var ObjectManagementSystem = _ObjectManagementSystem;
+
+export { ObjectManagementSystem, SHARED_MODEL_RESOURCE_FLAG, applyTransform, clearModelCache, createAnimationComponent, createAudioComponent, createBaseEntity, createBoneAttachmentComponent, createCameraComponent, createEntityTypeComponent, createEnvironmentComponent, createGLTFLoader, createIKComponent, createImageComponent, createImageTargetAnchorComponent, createImageTargetComponent, createInstanceSlotComponent, createInstancedMeshComponent, createLightComponent, createMaterialComponent, createMeshComponent, createMeshGeometryComponent, createModel, createModelComponent, createNameComponent, createNetworkIdentityComponent, createNetworkSpawnerComponent, createNetworkTransformComponent, createNetworkedPropsComponent, createObject3DRefComponent, createParentIdComponent, createPhysicsComponent, createPostprocessingComponent, createScriptComponent, createScriptObjectComponent, createSelectableComponent, createSelectionTransformStateComponent, createSpriteComponent, createTransform, createTransformComponent, createUIButtonComponent, createUIPanelComponent, createUISliderComponent, createUITextComponent, createUIToggleComponent, createVRTeleportAreaComponent, createVideoComponent, createXRAnchorComponent, createXRHandPoseComponent, createXRInteractableComponent, createXRInteractorComponent, createXRInteractorSideComponent, createXRRigComponent, findModelBone, listModelBones, loadSharedGltf, resolveDracoDecoderPath, setDracoDecoderPath };
+//# sourceMappingURL=chunk-G4XJ53LS.js.map
+//# sourceMappingURL=chunk-G4XJ53LS.js.map