@relu-interactives/spatial-ecs 0.2.2

package/dist/factories/index.cjs

@@ -0,0 +1,3077 @@
+'use strict';
+
+var THREE26 = require('three');
+var RectAreaLightHelper_js = require('three/examples/jsm/helpers/RectAreaLightHelper.js');
+var DRACOLoader_js = require('three/examples/jsm/loaders/DRACOLoader.js');
+var GLTFLoader_js = require('three/examples/jsm/loaders/GLTFLoader.js');
+
+var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var THREE26__namespace = /*#__PURE__*/_interopNamespace(THREE26);
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// core/Component.ts
+var _Component = class _Component {
+};
+__name(_Component, "Component");
+var Component = _Component;
+
+// core/AnimationStateMachine.ts
+var _AnimationStateMachine = class _AnimationStateMachine {
+  constructor(name, clip, callbacks = {}, loop = false, clipId = null) {
+    this.isPlaying = false;
+    this.isPaused = false;
+    this.name = name;
+    this.clip = clip;
+    this.clipId = clipId;
+    this.loop = loop;
+    this.callbacks = {
+      onStart: callbacks.onStart ?? (() => {
+      }),
+      onPlaying: callbacks.onPlaying ?? (() => {
+      }),
+      onEnd: callbacks.onEnd ?? (() => {
+      })
+    };
+  }
+  setCallbacks(callbacks) {
+    this.callbacks = {
+      onStart: callbacks.onStart ?? this.callbacks.onStart,
+      onPlaying: callbacks.onPlaying ?? this.callbacks.onPlaying,
+      onEnd: callbacks.onEnd ?? this.callbacks.onEnd
+    };
+  }
+  setLoop(loop) {
+    this.loop = loop;
+  }
+  onStart() {
+    this.callbacks.onStart();
+  }
+  onPlaying() {
+    this.callbacks.onPlaying();
+  }
+  onEnd() {
+    this.callbacks.onEnd();
+  }
+  play() {
+    const wasPlaying = this.isPlaying;
+    this.isPlaying = true;
+    this.isPaused = false;
+    if (!wasPlaying) {
+      this.onStart();
+    }
+    this.onPlaying();
+  }
+  pause() {
+    if (!this.isPlaying) {
+      return;
+    }
+    this.isPlaying = false;
+    this.isPaused = true;
+  }
+  stop() {
+    const shouldNotifyEnd = this.isPlaying || this.isPaused;
+    this.isPlaying = false;
+    this.isPaused = false;
+    if (shouldNotifyEnd) {
+      this.onEnd();
+    }
+  }
+};
+__name(_AnimationStateMachine, "AnimationStateMachine");
+var AnimationStateMachine = _AnimationStateMachine;
+var _AnimationStateManager = class _AnimationStateManager {
+  constructor() {
+    this.states = /* @__PURE__ */ new Map();
+    this.activeState = null;
+  }
+  addState(state) {
+    this.states.set(state.name, state);
+    return state;
+  }
+  createState(name, clip, callbacks = {}, loop = false, clipId = null) {
+    const state = new AnimationStateMachine(name, clip, callbacks, loop, clipId);
+    this.states.set(name, state);
+    return state;
+  }
+  removeState(name) {
+    const state = this.states.get(name);
+    if (!state) {
+      return false;
+    }
+    if (this.activeState?.name === name) {
+      this.activeState.stop();
+      this.activeState = null;
+    }
+    return this.states.delete(name);
+  }
+  getState(name) {
+    return this.states.get(name) ?? null;
+  }
+  hasState(name) {
+    return this.states.has(name);
+  }
+  listStates() {
+    return [...this.states.values()];
+  }
+  getActiveState() {
+    return this.activeState;
+  }
+  switchState(name, autoPlay = true) {
+    const next = this.states.get(name) ?? null;
+    if (!next) {
+      return null;
+    }
+    if (this.activeState && this.activeState !== next) {
+      this.activeState.stop();
+    }
+    this.activeState = next;
+    if (autoPlay) {
+      next.play();
+    }
+    return next;
+  }
+  playState(name) {
+    const state = name ? this.switchState(name, false) : this.activeState;
+    if (!state) {
+      return false;
+    }
+    this.activeState = state;
+    state.play();
+    return true;
+  }
+  pauseState(name) {
+    const state = name ? this.states.get(name) : this.activeState;
+    if (!state) {
+      return false;
+    }
+    state.pause();
+    return true;
+  }
+  stopState(name) {
+    const state = name ? this.states.get(name) : this.activeState;
+    if (!state) {
+      return false;
+    }
+    state.stop();
+    if (!name || this.activeState?.name === name) {
+      this.activeState = null;
+    }
+    return true;
+  }
+  clear() {
+    this.stopState();
+    this.states.clear();
+    this.activeState = null;
+  }
+};
+__name(_AnimationStateManager, "AnimationStateManager");
+var AnimationStateManager = _AnimationStateManager;
+
+// core/components/Animation.ts
+var _AnimationComponent = class _AnimationComponent extends Component {
+  constructor(options = {}) {
+    super();
+    this.modelClips = Array.isArray(options.clips) ? [...options.clips] : [];
+    this.importedClips = [];
+    this.clipById = /* @__PURE__ */ new Map();
+    this.clipEntriesById = /* @__PURE__ */ new Map();
+    this.clips = [];
+    this.clipCatalog = [];
+    this.availableClips = [];
+    this.externalClipSources = [];
+    this.setExternalClipSources(options.externalClipSources ?? []);
+    this.refreshClipCatalog();
+    this.paused = options.paused ?? false;
+    this.reverse = options.reverse ?? false;
+    this.timeScale = options.timeScale ?? 1;
+    this.crossFadeDuration = options.crossFadeDuration ?? 0;
+    this.stateManager = new AnimationStateManager();
+    this.states = this.stateManager.listStates();
+    this.active = this.stateManager.getActiveState();
+    this.activeStateName = this.active?.name ?? null;
+    if (Array.isArray(options.states) && options.states.length > 0) {
+      for (const entry of options.states) {
+        this.addState(entry.name, entry.clip, entry.loop ?? false);
+      }
+    }
+    if (typeof options.activeState === "string" && options.activeState.length > 0) {
+      this.switchState(options.activeState, !this.paused);
+    }
+  }
+  refreshClipCatalog() {
+    const catalog = [];
+    const nameCounts = /* @__PURE__ */ new Map();
+    const nextById = /* @__PURE__ */ new Map();
+    const nextEntriesById = /* @__PURE__ */ new Map();
+    for (const [index, clip] of this.modelClips.entries()) {
+      const name = typeof clip?.name === "string" && clip.name.length > 0 ? clip.name : `Clip ${index + 1}`;
+      const id = `model:${index}:${name}`;
+      const count = (nameCounts.get(name) ?? 0) + 1;
+      nameCounts.set(name, count);
+      const entry = {
+        id,
+        name,
+        label: count > 1 ? `${name} (${count})` : name,
+        clip,
+        source: "model",
+        sourceUrl: null
+      };
+      catalog.push(entry);
+      nextById.set(id, clip);
+      nextEntriesById.set(id, entry);
+    }
+    for (const [index, imported] of this.importedClips.entries()) {
+      const clip = imported.clip;
+      const name = typeof clip?.name === "string" && clip.name.length > 0 ? clip.name : `Clip ${index + 1}`;
+      const sourceUrl = imported.sourceUrl;
+      const id = `external:${index}:${name}`;
+      const count = (nameCounts.get(name) ?? 0) + 1;
+      nameCounts.set(name, count);
+      const sourceSuffix = sourceUrl ? sourceUrl.split("/").pop() ?? sourceUrl : "external";
+      const entry = {
+        id,
+        name,
+        label: count > 1 ? `${name} (${count}) \u2022 ${sourceSuffix}` : `${name} \u2022 ${sourceSuffix}`,
+        clip,
+        source: "external",
+        sourceUrl
+      };
+      catalog.push(entry);
+      nextById.set(id, clip);
+      nextEntriesById.set(id, entry);
+    }
+    this.clipById = nextById;
+    this.clipEntriesById = nextEntriesById;
+    this.clipCatalog = catalog;
+    this.clips = catalog.map((entry) => entry.clip);
+    this.availableClips = catalog.map((entry) => entry.name);
+  }
+  refreshStateRefs() {
+    this.states = this.stateManager.listStates();
+    this.active = this.stateManager.getActiveState();
+    this.activeStateName = this.active?.name ?? null;
+  }
+  resolveClipRef(clipRef) {
+    const trimmed = clipRef.trim();
+    if (!trimmed) {
+      return null;
+    }
+    const byId = this.clipById.get(trimmed);
+    if (byId) {
+      return { id: trimmed, clip: byId };
+    }
+    const byName = this.clipCatalog.find((entry) => entry.name === trimmed);
+    if (!byName) {
+      return null;
+    }
+    return { id: byName.id, clip: byName.clip };
+  }
+  setModelClips(clips) {
+    this.modelClips = Array.isArray(clips) ? [...clips] : [];
+    this.refreshClipCatalog();
+  }
+  setImportedClips(clips) {
+    if (!Array.isArray(clips)) {
+      this.importedClips = [];
+      this.refreshClipCatalog();
+      return;
+    }
+    this.importedClips = clips.map((entry) => {
+      if (entry instanceof THREE26__namespace.AnimationClip) {
+        return { clip: entry, sourceUrl: null };
+      }
+      if (!entry || typeof entry !== "object") {
+        return null;
+      }
+      const candidate = entry;
+      if (!(candidate.clip instanceof THREE26__namespace.AnimationClip)) {
+        return null;
+      }
+      return {
+        clip: candidate.clip,
+        sourceUrl: typeof candidate.sourceUrl === "string" && candidate.sourceUrl.length > 0 ? candidate.sourceUrl : null
+      };
+    }).filter((entry) => entry !== null);
+    this.refreshClipCatalog();
+  }
+  setExternalClipSources(sources) {
+    if (!Array.isArray(sources)) {
+      this.externalClipSources = [];
+      return;
+    }
+    const seen = /* @__PURE__ */ new Set();
+    const normalized = [];
+    for (const source of sources) {
+      if (typeof source !== "string") {
+        continue;
+      }
+      const trimmed = source.trim();
+      if (!trimmed || seen.has(trimmed)) {
+        continue;
+      }
+      seen.add(trimmed);
+      normalized.push(trimmed);
+    }
+    this.externalClipSources = normalized;
+  }
+  addState(name, clipRef, loop = false) {
+    if (!name.trim()) {
+      return null;
+    }
+    const resolved = this.resolveClipRef(clipRef);
+    if (!resolved) {
+      return null;
+    }
+    const state = this.stateManager.createState(name, resolved.clip, {}, loop, resolved.id);
+    this.refreshStateRefs();
+    return state;
+  }
+  setStates(states) {
+    const previousActive = this.activeStateName;
+    this.stateManager.clear();
+    for (const state of states) {
+      if (!state.name.trim()) {
+        continue;
+      }
+      let createdState = null;
+      if (typeof state.clipId === "string" && state.clipId.trim().length > 0) {
+        createdState = this.addState(state.name, state.clipId, Boolean(state.loop));
+      }
+      if (!createdState) {
+        this.addState(state.name, state.clip, Boolean(state.loop));
+      }
+    }
+    if (previousActive) {
+      this.stateManager.switchState(previousActive, !this.paused);
+    }
+    this.refreshStateRefs();
+  }
+  getStateConfigs() {
+    return this.states.map((state) => ({
+      name: state.name,
+      clip: state.clip.name,
+      clipId: state.clipId,
+      loop: state.loop
+    }));
+  }
+  setActiveState(name, autoPlay = true) {
+    if (!name) {
+      const stopped = this.stateManager.stopState();
+      this.paused = true;
+      this.refreshStateRefs();
+      return stopped;
+    }
+    return this.switchState(name, autoPlay);
+  }
+  removeState(name) {
+    const removed = this.stateManager.removeState(name);
+    if (removed) {
+      this.refreshStateRefs();
+    }
+    return removed;
+  }
+  switchState(name, autoPlay = true) {
+    const state = this.stateManager.switchState(name, autoPlay);
+    if (!state) {
+      return false;
+    }
+    this.paused = !state.isPlaying;
+    this.refreshStateRefs();
+    return true;
+  }
+  playState(name) {
+    const played = this.stateManager.playState(name);
+    if (!played) {
+      return false;
+    }
+    this.paused = false;
+    this.refreshStateRefs();
+    return true;
+  }
+  pauseState(name) {
+    const paused = this.stateManager.pauseState(name);
+    if (!paused) {
+      return false;
+    }
+    this.paused = true;
+    this.refreshStateRefs();
+    return true;
+  }
+  stopState(name) {
+    const stopped = this.stateManager.stopState(name);
+    if (!stopped) {
+      return false;
+    }
+    this.paused = true;
+    this.refreshStateRefs();
+    return true;
+  }
+};
+__name(_AnimationComponent, "AnimationComponent");
+var AnimationComponent = _AnimationComponent;
+
+// core/factories/components/AnimationFactory.ts
+function createAnimationComponent(world, entityId, ...args) {
+  const component = new AnimationComponent(...args);
+  world.addComponent(entityId, component);
+  return component;
+}
+__name(createAnimationComponent, "createAnimationComponent");
+
+// core/components/Audio.ts
+var DEFAULT_AUDIO_OPTIONS = {
+  autoplay: false,
+  loop: false,
+  pitch: 1,
+  volume: 1,
+  positional: false,
+  refDistance: 1,
+  distanceModel: "inverse",
+  rolloffFactor: 1
+};
+var _AudioComponent = class _AudioComponent extends Component {
+  constructor(path, options = {}) {
+    super();
+    this.path = path;
+    this.options = {
+      ...DEFAULT_AUDIO_OPTIONS,
+      ...options
+    };
+    this.object = null;
+    this.audio = null;
+    Object.defineProperty(this, "isPlaying", {
+      value: false,
+      writable: true,
+      configurable: true,
+      enumerable: false
+    });
+    Object.defineProperty(this, "isPaused", {
+      value: false,
+      writable: true,
+      configurable: true,
+      enumerable: false
+    });
+  }
+  /**
+   * Signals `AudioSystem` to start (or resume) playback.
+   * Has no direct effect in the editor — `AudioSystem` drives the actual
+   * THREE.js call in preview.
+   */
+  play() {
+    this.isPlaying = true;
+    this.isPaused = false;
+  }
+  /**
+   * Signals `AudioSystem` to pause playback, preserving the current position.
+   * Calling {@link play} afterwards resumes from where it paused.
+   * No-op if not currently playing.
+   */
+  pause() {
+    if (!this.isPlaying) return;
+    this.isPlaying = false;
+    this.isPaused = true;
+  }
+  /**
+   * Signals `AudioSystem` to stop playback and reset the playback position.
+   */
+  stop() {
+    this.isPlaying = false;
+    this.isPaused = false;
+  }
+};
+__name(_AudioComponent, "AudioComponent");
+var AudioComponent = _AudioComponent;
+
+// core/factories/components/AudioComponentFactory.ts
+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 THREE26__namespace.PositionalAudio(listener) : new THREE26__namespace.Audio(listener);
+  sound.setLoop(options.loop);
+  sound.setVolume(options.volume);
+  sound.setPlaybackRate(options.pitch);
+  if (sound instanceof THREE26__namespace.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 THREE26__namespace.EdgesGeometry(
+      new THREE26__namespace.OctahedronGeometry(0.22, 0)
+    );
+    const material2 = new THREE26__namespace.LineBasicMaterial({
+      color: "#8bc8ff",
+      transparent: true,
+      opacity: 0.95,
+      depthTest: false
+    });
+    const fallback = new THREE26__namespace.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 THREE26__namespace.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 THREE26__namespace.CanvasTexture(canvas);
+  texture.needsUpdate = true;
+  const material = new THREE26__namespace.SpriteMaterial({
+    map: texture,
+    transparent: true,
+    depthTest: false
+  });
+  const helper = new THREE26__namespace.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");
+var DEFAULT_FOV = 50;
+var DEFAULT_NEAR = 0.1;
+var DEFAULT_FAR = 2e3;
+var DEFAULT_ORTHO_LEFT = -5;
+var DEFAULT_ORTHO_RIGHT = 5;
+var DEFAULT_ORTHO_TOP = 5;
+var DEFAULT_ORTHO_BOTTOM = -5;
+var DEFAULT_ZOOM = 1;
+function inferProjection(camera) {
+  if (camera instanceof THREE26__namespace.OrthographicCamera) {
+    return "orthographic";
+  }
+  return "perspective";
+}
+__name(inferProjection, "inferProjection");
+function readCameraNear(camera) {
+  if (camera && "near" in camera && typeof camera.near === "number" && Number.isFinite(camera.near)) {
+    return camera.near;
+  }
+  return null;
+}
+__name(readCameraNear, "readCameraNear");
+function readCameraFar(camera) {
+  if (camera && "far" in camera && typeof camera.far === "number" && Number.isFinite(camera.far)) {
+    return camera.far;
+  }
+  return null;
+}
+__name(readCameraFar, "readCameraFar");
+function inferFov(camera) {
+  if (camera instanceof THREE26__namespace.PerspectiveCamera && Number.isFinite(camera.fov)) {
+    return camera.fov;
+  }
+  return DEFAULT_FOV;
+}
+__name(inferFov, "inferFov");
+function inferNear(camera) {
+  const near = readCameraNear(camera);
+  if (near !== null) {
+    return near;
+  }
+  return DEFAULT_NEAR;
+}
+__name(inferNear, "inferNear");
+function inferFar(camera) {
+  const far = readCameraFar(camera);
+  if (far !== null) {
+    return far;
+  }
+  return DEFAULT_FAR;
+}
+__name(inferFar, "inferFar");
+function inferOrthoLeft(camera) {
+  if (camera instanceof THREE26__namespace.OrthographicCamera && Number.isFinite(camera.left)) {
+    return camera.left;
+  }
+  return DEFAULT_ORTHO_LEFT;
+}
+__name(inferOrthoLeft, "inferOrthoLeft");
+function inferOrthoRight(camera) {
+  if (camera instanceof THREE26__namespace.OrthographicCamera && Number.isFinite(camera.right)) {
+    return camera.right;
+  }
+  return DEFAULT_ORTHO_RIGHT;
+}
+__name(inferOrthoRight, "inferOrthoRight");
+function inferOrthoTop(camera) {
+  if (camera instanceof THREE26__namespace.OrthographicCamera && Number.isFinite(camera.top)) {
+    return camera.top;
+  }
+  return DEFAULT_ORTHO_TOP;
+}
+__name(inferOrthoTop, "inferOrthoTop");
+function inferOrthoBottom(camera) {
+  if (camera instanceof THREE26__namespace.OrthographicCamera && Number.isFinite(camera.bottom)) {
+    return camera.bottom;
+  }
+  return DEFAULT_ORTHO_BOTTOM;
+}
+__name(inferOrthoBottom, "inferOrthoBottom");
+function inferZoom(camera) {
+  if (camera && "zoom" in camera && typeof camera.zoom === "number" && Number.isFinite(camera.zoom)) {
+    return camera.zoom;
+  }
+  return DEFAULT_ZOOM;
+}
+__name(inferZoom, "inferZoom");
+var _CameraComponent = class _CameraComponent extends Component {
+  constructor(payload = {}) {
+    super();
+    this.camera = payload.camera ?? new THREE26__namespace.PerspectiveCamera();
+    this.type = payload.type ?? "3d";
+    this.isDefault = typeof payload.isDefault === "boolean" ? payload.isDefault : false;
+    this.projection = payload.projection ?? inferProjection(payload.camera);
+    this.fov = typeof payload.fov === "number" && Number.isFinite(payload.fov) ? payload.fov : inferFov(payload.camera);
+    this.near = typeof payload.near === "number" && Number.isFinite(payload.near) ? payload.near : inferNear(payload.camera);
+    this.far = typeof payload.far === "number" && Number.isFinite(payload.far) ? payload.far : inferFar(payload.camera);
+    this.left = typeof payload.left === "number" && Number.isFinite(payload.left) ? payload.left : inferOrthoLeft(payload.camera);
+    this.right = typeof payload.right === "number" && Number.isFinite(payload.right) ? payload.right : inferOrthoRight(payload.camera);
+    this.top = typeof payload.top === "number" && Number.isFinite(payload.top) ? payload.top : inferOrthoTop(payload.camera);
+    this.bottom = typeof payload.bottom === "number" && Number.isFinite(payload.bottom) ? payload.bottom : inferOrthoBottom(payload.camera);
+    this.zoom = typeof payload.zoom === "number" && Number.isFinite(payload.zoom) ? payload.zoom : inferZoom(payload.camera);
+  }
+};
+__name(_CameraComponent, "CameraComponent");
+var CameraComponent = _CameraComponent;
+
+// core/components/Object3DRef.ts
+var _Object3DRef = class _Object3DRef extends Component {
+  constructor(object, visibility) {
+    super();
+    this.object = object;
+    this.visibility = typeof visibility === "boolean" ? visibility : Boolean(object.visible);
+  }
+};
+__name(_Object3DRef, "Object3DRef");
+var Object3DRef = _Object3DRef;
+
+// core/factories/components/CameraFactory.ts
+function createCameraComponent(world, entityId, payload = {}) {
+  const object = world.getComponent(entityId, Object3DRef)?.object;
+  const objectCamera = object instanceof THREE26__namespace.Camera ? object : void 0;
+  const component = new CameraComponent({
+    ...payload,
+    camera: payload.camera ?? objectCamera
+  });
+  world.addComponent(entityId, component);
+  return component;
+}
+__name(createCameraComponent, "createCameraComponent");
+
+// core/components/Physics.ts
+var DEFAULT_RIGIDBODY_STATE = {
+  enabled: true,
+  type: "dynamic",
+  mass: 1,
+  linearDamping: 0,
+  angularDamping: 0,
+  gravityScale: 1,
+  canSleep: true,
+  ccdEnabled: false,
+  lockTranslations: false,
+  lockRotations: false};
+var DEFAULT_COLLIDER_STATE = {
+  enabled: true,
+  shape: "cuboid",
+  offsetPosition: {
+    x: 0,
+    y: 0,
+    z: 0
+  },
+  offsetRotation: {
+    x: 0,
+    y: 0,
+    z: 0
+  },
+  size: {
+    x: 1,
+    y: 1,
+    z: 1
+  },
+  radius: 0.5,
+  height: 1,
+  restitution: 0,
+  friction: 0.5,
+  isSensor: false
+};
+function asRecord(value) {
+  if (!value || typeof value !== "object") {
+    return null;
+  }
+  return value;
+}
+__name(asRecord, "asRecord");
+function toFiniteNumber(value, fallback) {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    return fallback;
+  }
+  return value;
+}
+__name(toFiniteNumber, "toFiniteNumber");
+function toBoolean(value, fallback) {
+  if (typeof value !== "boolean") {
+    return fallback;
+  }
+  return value;
+}
+__name(toBoolean, "toBoolean");
+function toRigidbodyType(value, fallback) {
+  if (value === "dynamic" || value === "fixed" || value === "kinematicPosition" || value === "kinematicVelocity") {
+    return value;
+  }
+  return fallback;
+}
+__name(toRigidbodyType, "toRigidbodyType");
+function toColliderShape(value, fallback) {
+  if (value === "cuboid" || value === "ball" || value === "capsule" || value === "cylinder" || value === "trimesh") {
+    return value;
+  }
+  return fallback;
+}
+__name(toColliderShape, "toColliderShape");
+function normalizeRigidbodyState(value) {
+  const source = asRecord(value);
+  const defaults = DEFAULT_RIGIDBODY_STATE;
+  const legacyLockTranslations = toBoolean(
+    source?.lockTranslations,
+    defaults.lockTranslations
+  );
+  const legacyLockRotations = toBoolean(
+    source?.lockRotations,
+    defaults.lockRotations
+  );
+  const lockTranslationX = toBoolean(
+    source?.lockTranslationX,
+    legacyLockTranslations
+  );
+  const lockTranslationY = toBoolean(
+    source?.lockTranslationY,
+    legacyLockTranslations
+  );
+  const lockTranslationZ = toBoolean(
+    source?.lockTranslationZ,
+    legacyLockTranslations
+  );
+  const lockRotationX = toBoolean(source?.lockRotationX, legacyLockRotations);
+  const lockRotationY = toBoolean(source?.lockRotationY, legacyLockRotations);
+  const lockRotationZ = toBoolean(source?.lockRotationZ, legacyLockRotations);
+  return {
+    enabled: toBoolean(source?.enabled, defaults.enabled),
+    type: toRigidbodyType(source?.type, defaults.type),
+    mass: Math.max(1e-4, toFiniteNumber(source?.mass, defaults.mass)),
+    linearDamping: Math.max(
+      0,
+      toFiniteNumber(source?.linearDamping, defaults.linearDamping)
+    ),
+    angularDamping: Math.max(
+      0,
+      toFiniteNumber(source?.angularDamping, defaults.angularDamping)
+    ),
+    gravityScale: toFiniteNumber(source?.gravityScale, defaults.gravityScale),
+    canSleep: toBoolean(source?.canSleep, defaults.canSleep),
+    ccdEnabled: toBoolean(source?.ccdEnabled, defaults.ccdEnabled),
+    lockTranslations: legacyLockTranslations,
+    lockTranslationX,
+    lockTranslationY,
+    lockTranslationZ,
+    lockRotations: legacyLockRotations,
+    lockRotationX,
+    lockRotationY,
+    lockRotationZ
+  };
+}
+__name(normalizeRigidbodyState, "normalizeRigidbodyState");
+function normalizeColliderState(value) {
+  const source = asRecord(value);
+  const defaults = DEFAULT_COLLIDER_STATE;
+  const offsetPosition = asRecord(source?.offsetPosition);
+  const offsetRotation = asRecord(source?.offsetRotation);
+  const size = asRecord(source?.size);
+  return {
+    enabled: toBoolean(source?.enabled, defaults.enabled),
+    shape: toColliderShape(source?.shape, defaults.shape),
+    offsetPosition: {
+      x: toFiniteNumber(offsetPosition?.x, defaults.offsetPosition.x),
+      y: toFiniteNumber(offsetPosition?.y, defaults.offsetPosition.y),
+      z: toFiniteNumber(offsetPosition?.z, defaults.offsetPosition.z)
+    },
+    offsetRotation: {
+      x: toFiniteNumber(offsetRotation?.x, defaults.offsetRotation.x),
+      y: toFiniteNumber(offsetRotation?.y, defaults.offsetRotation.y),
+      z: toFiniteNumber(offsetRotation?.z, defaults.offsetRotation.z)
+    },
+    size: {
+      x: Math.max(1e-4, toFiniteNumber(size?.x, defaults.size.x)),
+      y: Math.max(1e-4, toFiniteNumber(size?.y, defaults.size.y)),
+      z: Math.max(1e-4, toFiniteNumber(size?.z, defaults.size.z))
+    },
+    radius: Math.max(1e-4, toFiniteNumber(source?.radius, defaults.radius)),
+    height: Math.max(1e-4, toFiniteNumber(source?.height, defaults.height)),
+    restitution: Math.max(0, toFiniteNumber(source?.restitution, defaults.restitution)),
+    friction: Math.max(0, toFiniteNumber(source?.friction, defaults.friction)),
+    isSensor: toBoolean(source?.isSensor, defaults.isSensor)
+  };
+}
+__name(normalizeColliderState, "normalizeColliderState");
+function normalizePhysicsState(value) {
+  const source = asRecord(value);
+  return {
+    rigidbody: normalizeRigidbodyState(
+      source?.rigidbody ?? void 0
+    ),
+    collider: normalizeColliderState(
+      source?.collider ?? void 0
+    )
+  };
+}
+__name(normalizePhysicsState, "normalizePhysicsState");
+var _PhysicsComponent = class _PhysicsComponent extends Component {
+  constructor(values) {
+    super();
+    this.values = normalizePhysicsState(values);
+    this.rigidBody = null;
+    this.collider = null;
+  }
+  /**
+   * Patch rigidbody and/or collider state. Each sub-object is deep-merged
+   * with the current values via the respective normalizer.
+   */
+  setValues(patch) {
+    this.values = normalizePhysicsState({
+      rigidbody: { ...this.values.rigidbody, ...patch.rigidbody ?? {} },
+      collider: { ...this.values.collider, ...patch.collider ?? {} }
+    });
+  }
+};
+__name(_PhysicsComponent, "PhysicsComponent");
+var PhysicsComponent = _PhysicsComponent;
+
+// core/factories/components/PhysicsFactory.ts
+function createPhysicsComponent(world, entityId, values) {
+  const component = new PhysicsComponent(values);
+  world.addComponent(entityId, component);
+  return component;
+}
+__name(createPhysicsComponent, "createPhysicsComponent");
+
+// core/components/Environment.ts
+var DEFAULT_ENVIRONMENT_STATE = {
+  skybox: {
+    type: "none",
+    color: "#1e1e1e",
+    imageUrl: "",
+    gradient: {
+      colors: ["#464766", "#657ea6", "#0f0e1a"],
+      effect: "linear"
+    }
+  },
+  fog: {
+    type: "none",
+    color: "#1e1e1e",
+    linear: {
+      near: 1,
+      far: 100
+    },
+    exponential: {
+      density: 2e-3
+    }
+  },
+  gravity: {
+    x: 0,
+    y: -9.81,
+    z: 0
+  },
+  fixedTimeStep: 0.02
+};
+function normalizeColors(colors) {
+  if (!Array.isArray(colors)) {
+    return [...DEFAULT_ENVIRONMENT_STATE.skybox.gradient.colors];
+  }
+  const normalized = colors.filter(
+    (entry) => typeof entry === "string" && entry.length > 0
+  );
+  if (normalized.length === 0) {
+    return [...DEFAULT_ENVIRONMENT_STATE.skybox.gradient.colors];
+  }
+  return normalized;
+}
+__name(normalizeColors, "normalizeColors");
+function normalizeGradientEffect(value) {
+  if (value === "radial" || value === "linear" || value === "angular") {
+    return value;
+  }
+  return DEFAULT_ENVIRONMENT_STATE.skybox.gradient.effect;
+}
+__name(normalizeGradientEffect, "normalizeGradientEffect");
+function normalizeSkyboxType(value) {
+  if (value === "gradient" || value === "color" || value === "none") {
+    return value;
+  }
+  if (value === "image" || value === "Image") {
+    return "image";
+  }
+  return DEFAULT_ENVIRONMENT_STATE.skybox.type;
+}
+__name(normalizeSkyboxType, "normalizeSkyboxType");
+function normalizeFogType(value) {
+  if (value === "linear" || value === "exponential" || value === "none") {
+    return value;
+  }
+  return DEFAULT_ENVIRONMENT_STATE.fog.type;
+}
+__name(normalizeFogType, "normalizeFogType");
+function toFiniteNumber2(value, fallback) {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    return fallback;
+  }
+  return value;
+}
+__name(toFiniteNumber2, "toFiniteNumber");
+var _Environment = class _Environment extends Component {
+  constructor(values) {
+    super();
+    const skybox = values?.skybox;
+    const fog = values?.fog;
+    const gravity = values?.gravity;
+    this.values = {
+      skybox: {
+        type: normalizeSkyboxType(skybox?.type),
+        color: typeof skybox?.color === "string" ? skybox.color : DEFAULT_ENVIRONMENT_STATE.skybox.color,
+        imageUrl: typeof skybox?.imageUrl === "string" ? skybox.imageUrl : DEFAULT_ENVIRONMENT_STATE.skybox.imageUrl,
+        gradient: {
+          colors: normalizeColors(skybox?.gradient?.colors),
+          effect: normalizeGradientEffect(skybox?.gradient?.effect)
+        }
+      },
+      fog: {
+        type: normalizeFogType(fog?.type),
+        color: typeof fog?.color === "string" ? fog.color : DEFAULT_ENVIRONMENT_STATE.fog.color,
+        linear: {
+          near: toFiniteNumber2(
+            fog?.linear?.near,
+            DEFAULT_ENVIRONMENT_STATE.fog.linear.near
+          ),
+          far: toFiniteNumber2(
+            fog?.linear?.far,
+            DEFAULT_ENVIRONMENT_STATE.fog.linear.far
+          )
+        },
+        exponential: {
+          density: toFiniteNumber2(
+            fog?.exponential?.density,
+            DEFAULT_ENVIRONMENT_STATE.fog.exponential.density
+          )
+        }
+      },
+      gravity: {
+        x: toFiniteNumber2(gravity?.x, DEFAULT_ENVIRONMENT_STATE.gravity.x),
+        y: toFiniteNumber2(gravity?.y, DEFAULT_ENVIRONMENT_STATE.gravity.y),
+        z: toFiniteNumber2(gravity?.z, DEFAULT_ENVIRONMENT_STATE.gravity.z)
+      },
+      fixedTimeStep: toFiniteNumber2(
+        values?.fixedTimeStep,
+        DEFAULT_ENVIRONMENT_STATE.fixedTimeStep
+      )
+    };
+  }
+};
+__name(_Environment, "Environment");
+var Environment = _Environment;
+
+// 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/components/EntityType.ts
+var _EntityType = class _EntityType extends Component {
+  constructor(value) {
+    super();
+    this.value = value;
+  }
+};
+__name(_EntityType, "EntityType");
+var EntityType = _EntityType;
+
+// 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/components/Image.ts
+var _ImageComponent = class _ImageComponent extends Component {
+  constructor(path, width = 1, height = 1) {
+    super();
+    this.path = path;
+    this.width = width;
+    this.height = height;
+    this.texture = null;
+    this.object = null;
+  }
+};
+__name(_ImageComponent, "ImageComponent");
+var ImageComponent = _ImageComponent;
+
+// core/factories/components/ImageComponentFactory.ts
+function createImageComponent(world, entityId, ...args) {
+  const component = new ImageComponent(...args);
+  world.addComponent(entityId, component);
+  return component;
+}
+__name(createImageComponent, "createImageComponent");
+
+// core/components/ImageTargetAnchor.ts
+var _ImageTargetAnchor = class _ImageTargetAnchor extends Component {
+  constructor(options) {
+    super();
+    this.targetId = options?.targetId ?? null;
+    this.targetUrl = options?.targetUrl;
+  }
+};
+__name(_ImageTargetAnchor, "ImageTargetAnchor");
+var ImageTargetAnchor = _ImageTargetAnchor;
+
+// 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/components/ImageTarget.ts
+var _ImageTarget = class _ImageTarget extends Component {
+  constructor(options, texture, object) {
+    super();
+    this.targets = options?.targets ?? [];
+    this.compiledTargetUrl = options?.compiledTargetUrl;
+    this.compiledTargetDir = options?.compiledTargetDir;
+    this.texture = texture ?? null;
+    this.object = object ?? null;
+  }
+};
+__name(_ImageTarget, "ImageTarget");
+var ImageTarget = _ImageTarget;
+
+// core/factories/components/ImageTargetFactory.ts
+function createImageTargetComponent(world, entityId, ...args) {
+  const component = new ImageTarget(...args);
+  world.addComponent(entityId, component);
+  return component;
+}
+__name(createImageTargetComponent, "createImageTargetComponent");
+function toHexColor(value) {
+  return `#${value.getHexString()}`;
+}
+__name(toHexColor, "toHexColor");
+function createValueState(light) {
+  const base = {
+    color: toHexColor(light.color),
+    intensity: light.intensity,
+    castShadow: light.castShadow ?? false,
+    frustumCulling: light.frustumCulled
+  };
+  if (light instanceof THREE26__namespace.PointLight) {
+    base.distance = light.distance;
+    base.decay = light.decay;
+  } else if (light instanceof THREE26__namespace.SpotLight) {
+    base.distance = light.distance;
+    base.decay = light.decay;
+    base.angle = light.angle;
+    base.penumbra = light.penumbra;
+  } else if (light instanceof THREE26__namespace.RectAreaLight) {
+    base.width = light.width;
+    base.height = light.height;
+  }
+  return base;
+}
+__name(createValueState, "createValueState");
+var _LightComponent = class _LightComponent extends Component {
+  constructor(light) {
+    super();
+    this.light = light;
+    this.type = light.type;
+    this.values = createValueState(light);
+  }
+  setValues(patch) {
+    this.values = {
+      ...this.values,
+      ...patch
+    };
+  }
+};
+__name(_LightComponent, "LightComponent");
+var LightComponent = _LightComponent;
+
+// core/factories/components/LightFactory.ts
+function createLightComponent(world, entityId, ...args) {
+  const component = new LightComponent(...args);
+  world.addComponent(entityId, component);
+  return component;
+}
+__name(createLightComponent, "createLightComponent");
+function toHexColor2(value, fallback) {
+  if (value && typeof value === "object" && typeof value.getHexString === "function") {
+    try {
+      return `#${value.getHexString()}`;
+    } catch {
+      return fallback;
+    }
+  }
+  return fallback;
+}
+__name(toHexColor2, "toHexColor");
+function getMaterialType(material) {
+  if (material instanceof THREE26__namespace.MeshPhysicalMaterial) {
+    return "physical";
+  }
+  if (material instanceof THREE26__namespace.MeshPhongMaterial) {
+    return "phong";
+  }
+  if (material instanceof THREE26__namespace.MeshBasicMaterial) {
+    return "basic";
+  }
+  return "standard";
+}
+__name(getMaterialType, "getMaterialType");
+function createMaterialValue(material) {
+  const materialRecord = material;
+  const normalScale = materialRecord.normalScale;
+  const map = materialRecord.map;
+  return {
+    type: getMaterialType(material),
+    color: toHexColor2(materialRecord.color, "#ffffff"),
+    roughness: typeof materialRecord.roughness === "number" ? materialRecord.roughness : 0.5,
+    metalness: typeof materialRecord.metalness === "number" ? materialRecord.metalness : 0.5,
+    normalScale: typeof normalScale?.x === "number" ? normalScale.x : 1,
+    opacity: typeof materialRecord.opacity === "number" ? materialRecord.opacity : 1,
+    emissive: toHexColor2(materialRecord.emissive, "#000000"),
+    emissiveIntensity: typeof materialRecord.emissiveIntensity === "number" ? materialRecord.emissiveIntensity : 0,
+    side: typeof materialRecord.side === "number" ? materialRecord.side : THREE26__namespace.FrontSide,
+    blending: typeof materialRecord.blending === "number" ? materialRecord.blending : THREE26__namespace.NormalBlending,
+    depthTest: materialRecord.depthTest !== false,
+    depthWrite: materialRecord.depthWrite !== false,
+    wireframe: Boolean(materialRecord.wireframe),
+    transparent: Boolean(materialRecord.transparent),
+    textureMap: map?.image ? map.source?.data?.currentSrc || map.image?.src : void 0,
+    alphaTextureMap: materialRecord.alphaMap?.image?.src,
+    normalMap: materialRecord.normalMap?.image?.src,
+    roughnessMap: materialRecord.roughnessMap?.image?.src,
+    metalnessMap: materialRecord.metalnessMap?.image?.src,
+    aoMap: materialRecord.aoMap?.image?.src,
+    emissiveMap: materialRecord.emissiveMap?.image?.src,
+    bumpMap: materialRecord.bumpMap?.image?.src,
+    displacementMap: materialRecord.displacementMap?.image?.src,
+    lightMap: materialRecord.lightMap?.image?.src,
+    envMap: materialRecord.envMap?.image?.src,
+    textureFiltering: map?.magFilter === THREE26__namespace.NearestFilter ? "sharp" : "smooth",
+    useMipmaps: map?.generateMipmaps !== false
+  };
+}
+__name(createMaterialValue, "createMaterialValue");
+function defaultMaterialValue() {
+  return {
+    type: "standard",
+    color: "#ffffff",
+    roughness: 0.5,
+    metalness: 0.5,
+    normalScale: 1,
+    opacity: 1,
+    emissive: "#000000",
+    emissiveIntensity: 0,
+    side: THREE26__namespace.FrontSide,
+    blending: THREE26__namespace.NormalBlending,
+    depthTest: true,
+    depthWrite: true,
+    wireframe: false,
+    transparent: false,
+    textureFiltering: "smooth",
+    useMipmaps: true
+  };
+}
+__name(defaultMaterialValue, "defaultMaterialValue");
+var _MaterialComponent = class _MaterialComponent extends Component {
+  constructor(materialOrMaterials = []) {
+    super();
+    this.materials = [];
+    this.material = null;
+    this.values = [];
+    this.setMaterials(materialOrMaterials);
+  }
+  setMaterials(materialOrMaterials = []) {
+    this.materials = Array.isArray(materialOrMaterials) ? materialOrMaterials.filter(Boolean) : materialOrMaterials ? [materialOrMaterials] : [];
+    this.material = this.materials[0] ?? null;
+    this.values = this.materials.length > 0 ? this.materials.map((material) => createMaterialValue(material)) : [defaultMaterialValue()];
+  }
+  updateValue(index, patch) {
+    if (index < 0) {
+      return;
+    }
+    while (this.values.length <= index) {
+      this.values.push(defaultMaterialValue());
+    }
+    this.values[index] = {
+      ...this.values[index],
+      ...patch
+    };
+  }
+  resetValue(index) {
+    if (index < 0) {
+      return;
+    }
+    while (this.values.length <= index) {
+      this.values.push(defaultMaterialValue());
+    }
+    const type = this.values[index]?.type ?? "standard";
+    this.values[index] = {
+      ...defaultMaterialValue(),
+      type
+    };
+  }
+  setMaterialType(index, type) {
+    this.updateValue(index, { type });
+  }
+  setTextureFiltering(index, filtering) {
+    this.updateValue(index, { textureFiltering: filtering });
+  }
+  setUseMipmaps(index, enabled) {
+    this.updateValue(index, { useMipmaps: enabled });
+  }
+};
+__name(_MaterialComponent, "MaterialComponent");
+var MaterialComponent = _MaterialComponent;
+
+// core/factories/components/MaterialFactory.ts
+function createMaterialComponent(world, entityId, ...args) {
+  const component = new MaterialComponent(...args);
+  world.addComponent(entityId, component);
+  return component;
+}
+__name(createMaterialComponent, "createMaterialComponent");
+
+// core/components/Mesh.ts
+var _MeshComponent = class _MeshComponent extends Component {
+  constructor(mesh) {
+    super();
+    this.mesh = mesh;
+  }
+};
+__name(_MeshComponent, "MeshComponent");
+var MeshComponent = _MeshComponent;
+
+// core/factories/components/MeshFactory.ts
+function createMeshComponent(world, entityId, ...args) {
+  const component = new MeshComponent(...args);
+  world.addComponent(entityId, component);
+  return component;
+}
+__name(createMeshComponent, "createMeshComponent");
+var DEFAULT_MESH_GEOMETRY_PARAMETERS = {
+  capsule: { radius: 0.5, height: 1 },
+  cube: { width: 1, height: 1, depth: 1 },
+  cylinder: { radius: 0.5, height: 1 },
+  plane: { width: 100, height: 100 },
+  sphere: { radius: 0.5 }
+};
+var GEOMETRY_TYPE_BY_KIND = {
+  capsule: "CapsuleGeometry",
+  cube: "BoxGeometry",
+  cylinder: "CylinderGeometry",
+  model: "Model",
+  plane: "PlaneGeometry",
+  sphere: "SphereGeometry"
+};
+var _MeshGeometryComponent = class _MeshGeometryComponent extends Component {
+  constructor(kind, object, parameters, options) {
+    super();
+    this.kind = kind;
+    this.geometryType = GEOMETRY_TYPE_BY_KIND[kind];
+    this.object = object;
+    this.modelName = options?.modelName ?? "";
+    this.castShadow = options?.castShadow ?? false;
+    this.receiveShadow = options?.receiveShadow ?? false;
+    switch (kind) {
+      case "cube":
+        this.parameters = {
+          ...DEFAULT_MESH_GEOMETRY_PARAMETERS.cube,
+          ...parameters
+        };
+        break;
+      case "plane":
+        this.parameters = {
+          ...DEFAULT_MESH_GEOMETRY_PARAMETERS.plane,
+          ...parameters
+        };
+        break;
+      case "sphere":
+        this.parameters = {
+          ...DEFAULT_MESH_GEOMETRY_PARAMETERS.sphere,
+          ...parameters
+        };
+        break;
+      case "cylinder":
+        this.parameters = {
+          ...DEFAULT_MESH_GEOMETRY_PARAMETERS.cylinder,
+          ...parameters
+        };
+        break;
+      case "capsule":
+        this.parameters = {
+          ...DEFAULT_MESH_GEOMETRY_PARAMETERS.capsule,
+          ...parameters
+        };
+        break;
+      case "model":
+        this.parameters = {};
+        break;
+    }
+  }
+};
+__name(_MeshGeometryComponent, "MeshGeometryComponent");
+var MeshGeometryComponent = _MeshGeometryComponent;
+
+// core/factories/components/MeshGeometryFactory.ts
+function createMeshGeometryComponent(world, entityId, ...args) {
+  const component = new MeshGeometryComponent(...args);
+  world.addComponent(entityId, component);
+  return component;
+}
+__name(createMeshGeometryComponent, "createMeshGeometryComponent");
+
+// core/components/Model.ts
+var _ModelComponent = class _ModelComponent extends Component {
+  constructor(path) {
+    super();
+    this.path = path;
+    this.object = null;
+  }
+};
+__name(_ModelComponent, "ModelComponent");
+var ModelComponent = _ModelComponent;
+
+// 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/components/Name.ts
+var _Name = class _Name extends Component {
+  constructor(value) {
+    super();
+    this.value = value;
+  }
+};
+__name(_Name, "Name");
+var Name = _Name;
+
+// 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/components/ParentId.ts
+var _ParentId = class _ParentId extends Component {
+  constructor(value = null) {
+    super();
+    this.value = value;
+  }
+};
+__name(_ParentId, "ParentId");
+var ParentId = _ParentId;
+
+// 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/components/Postprocessing.ts
+var DEFAULT_POSTPROCESSING_STATE = {
+  postEnabled: false,
+  dof: {
+    enabled: false,
+    focusDistance: 0.015,
+    focalLength: 0.018,
+    bokehScale: 3
+  },
+  bloom: {
+    enabled: false,
+    intensity: 1.2,
+    threshold: 0.2,
+    radius: 0.7
+  },
+  vignette: {
+    enabled: false,
+    offset: 0.05,
+    darkness: 1.2
+  },
+  chromAberration: {
+    enabled: false,
+    offsetX: 3e-3,
+    offsetY: 3e-3
+  },
+  noise: {
+    enabled: false,
+    opacity: 0.12
+  },
+  pixelation: {
+    enabled: false,
+    granularity: 6
+  },
+  toneMapping: {
+    enabled: false,
+    exposure: 1.3
+  },
+  hueSaturation: {
+    enabled: false,
+    hue: 0.05,
+    saturation: 0.2
+  },
+  sepia: {
+    enabled: false,
+    intensity: 0.5
+  },
+  smaa: {
+    enabled: false
+  },
+  ssao: {
+    enabled: false,
+    intensity: 1.5,
+    radius: 0.25
+  },
+  dotScreen: {
+    enabled: false,
+    dotScreenScale: 1.2,
+    dotScreenAngle: 1.57,
+    blendFunction: void 0,
+    opacity: void 0
+  },
+  glitch: {
+    enabled: false,
+    blendFunction: void 0,
+    delay: void 0,
+    duration: void 0,
+    dtSize: void 0,
+    columns: void 0,
+    ratio: void 0,
+    mode: void 0}
+};
+function asRecord2(value) {
+  if (!value || typeof value !== "object") {
+    return null;
+  }
+  return value;
+}
+__name(asRecord2, "asRecord");
+function toFiniteNumber3(value, fallback) {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    return fallback;
+  }
+  return value;
+}
+__name(toFiniteNumber3, "toFiniteNumber");
+function toBoolean2(value, fallback) {
+  if (typeof value !== "boolean") {
+    return fallback;
+  }
+  return value;
+}
+__name(toBoolean2, "toBoolean");
+function normalizeNumberTuple(value) {
+  if (!Array.isArray(value) || value.length !== 2) {
+    return void 0;
+  }
+  if (typeof value[0] !== "number" || !Number.isFinite(value[0]) || typeof value[1] !== "number" || !Number.isFinite(value[1])) {
+    return void 0;
+  }
+  return [value[0], value[1]];
+}
+__name(normalizeNumberTuple, "normalizeNumberTuple");
+function normalizePostprocessing(value) {
+  const postprocessing = asRecord2(value);
+  const defaults = DEFAULT_POSTPROCESSING_STATE;
+  const dof = asRecord2(postprocessing?.dof);
+  const bloom = asRecord2(postprocessing?.bloom);
+  const vignette = asRecord2(postprocessing?.vignette);
+  const chromAberration = asRecord2(postprocessing?.chromAberration);
+  const noise = asRecord2(postprocessing?.noise);
+  const pixelation = asRecord2(postprocessing?.pixelation);
+  const toneMapping = asRecord2(postprocessing?.toneMapping);
+  const hueSaturation = asRecord2(postprocessing?.hueSaturation);
+  const sepia = asRecord2(postprocessing?.sepia);
+  const smaa = asRecord2(postprocessing?.smaa);
+  const ssao = asRecord2(postprocessing?.ssao);
+  const dotScreen = asRecord2(postprocessing?.dotScreen);
+  const glitch = asRecord2(postprocessing?.glitch);
+  const glitchChromaticAberrationOffset = asRecord2(
+    glitch?.chromaticAberrationOffset
+  );
+  const glitchStrength = asRecord2(glitch?.strength);
+  const dotScreenScale = toFiniteNumber3(
+    dotScreen?.dotScreenScale,
+    defaults.dotScreen.dotScreenScale
+  );
+  const dotScreenAngle = toFiniteNumber3(
+    dotScreen?.dotScreenAngle,
+    defaults.dotScreen.dotScreenAngle
+  );
+  const normalizedGlitchStrength = typeof glitch?.strength === "number" && Number.isFinite(glitch.strength) ? glitch.strength : glitchStrength && typeof glitchStrength.x === "number" && Number.isFinite(glitchStrength.x) && typeof glitchStrength.y === "number" && Number.isFinite(glitchStrength.y) ? { x: glitchStrength.x, y: glitchStrength.y } : void 0;
+  const normalizedGlitchChromaticAberrationOffset = normalizeNumberTuple(glitch?.chromaticAberrationOffset) ?? (glitchChromaticAberrationOffset && typeof glitchChromaticAberrationOffset.x === "number" && Number.isFinite(glitchChromaticAberrationOffset.x) && typeof glitchChromaticAberrationOffset.y === "number" && Number.isFinite(glitchChromaticAberrationOffset.y) ? {
+    x: glitchChromaticAberrationOffset.x,
+    y: glitchChromaticAberrationOffset.y
+  } : void 0);
+  return {
+    postEnabled: toBoolean2(postprocessing?.postEnabled, defaults.postEnabled),
+    dof: {
+      enabled: toBoolean2(dof?.enabled, defaults.dof.enabled),
+      focusDistance: toFiniteNumber3(dof?.focusDistance, defaults.dof.focusDistance),
+      focalLength: toFiniteNumber3(dof?.focalLength, defaults.dof.focalLength),
+      bokehScale: toFiniteNumber3(dof?.bokehScale, defaults.dof.bokehScale)
+    },
+    bloom: {
+      enabled: toBoolean2(bloom?.enabled, defaults.bloom.enabled),
+      intensity: toFiniteNumber3(bloom?.intensity, defaults.bloom.intensity),
+      threshold: toFiniteNumber3(bloom?.threshold, defaults.bloom.threshold),
+      radius: toFiniteNumber3(bloom?.radius, defaults.bloom.radius)
+    },
+    vignette: {
+      enabled: toBoolean2(vignette?.enabled, defaults.vignette.enabled),
+      offset: toFiniteNumber3(vignette?.offset, defaults.vignette.offset),
+      darkness: toFiniteNumber3(vignette?.darkness, defaults.vignette.darkness)
+    },
+    chromAberration: {
+      enabled: toBoolean2(chromAberration?.enabled, defaults.chromAberration.enabled),
+      offsetX: toFiniteNumber3(chromAberration?.offsetX, defaults.chromAberration.offsetX),
+      offsetY: toFiniteNumber3(chromAberration?.offsetY, defaults.chromAberration.offsetY)
+    },
+    noise: {
+      enabled: toBoolean2(noise?.enabled, defaults.noise.enabled),
+      opacity: toFiniteNumber3(noise?.opacity, defaults.noise.opacity)
+    },
+    pixelation: {
+      enabled: toBoolean2(pixelation?.enabled, defaults.pixelation.enabled),
+      granularity: toFiniteNumber3(pixelation?.granularity, defaults.pixelation.granularity)
+    },
+    toneMapping: {
+      enabled: toBoolean2(toneMapping?.enabled, defaults.toneMapping.enabled),
+      exposure: toFiniteNumber3(toneMapping?.exposure, defaults.toneMapping.exposure)
+    },
+    hueSaturation: {
+      enabled: toBoolean2(hueSaturation?.enabled, defaults.hueSaturation.enabled),
+      hue: toFiniteNumber3(hueSaturation?.hue, defaults.hueSaturation.hue),
+      saturation: toFiniteNumber3(
+        hueSaturation?.saturation,
+        defaults.hueSaturation.saturation
+      )
+    },
+    sepia: {
+      enabled: toBoolean2(sepia?.enabled, defaults.sepia.enabled),
+      intensity: toFiniteNumber3(sepia?.intensity, defaults.sepia.intensity)
+    },
+    smaa: {
+      enabled: toBoolean2(smaa?.enabled, defaults.smaa.enabled)
+    },
+    ssao: {
+      enabled: toBoolean2(ssao?.enabled, defaults.ssao.enabled),
+      intensity: toFiniteNumber3(ssao?.intensity, defaults.ssao.intensity),
+      radius: toFiniteNumber3(ssao?.radius, defaults.ssao.radius)
+    },
+    dotScreen: {
+      enabled: toBoolean2(dotScreen?.enabled, defaults.dotScreen.enabled),
+      dotScreenScale,
+      dotScreenAngle,
+      scale: toFiniteNumber3(dotScreen?.scale, dotScreenScale),
+      angle: toFiniteNumber3(dotScreen?.angle, dotScreenAngle),
+      blendFunction: typeof dotScreen?.blendFunction === "number" && Number.isFinite(dotScreen.blendFunction) ? dotScreen.blendFunction : defaults.dotScreen.blendFunction,
+      opacity: typeof dotScreen?.opacity === "number" && Number.isFinite(dotScreen.opacity) ? dotScreen.opacity : defaults.dotScreen.opacity
+    },
+    glitch: {
+      enabled: toBoolean2(glitch?.enabled, defaults.glitch.enabled),
+      blendFunction: typeof glitch?.blendFunction === "number" && Number.isFinite(glitch.blendFunction) ? glitch.blendFunction : defaults.glitch.blendFunction,
+      chromaticAberrationOffset: normalizedGlitchChromaticAberrationOffset,
+      delay: normalizeNumberTuple(glitch?.delay) ?? defaults.glitch.delay,
+      duration: normalizeNumberTuple(glitch?.duration) ?? defaults.glitch.duration,
+      strength: normalizedGlitchStrength,
+      dtSize: typeof glitch?.dtSize === "number" && Number.isFinite(glitch.dtSize) ? glitch.dtSize : defaults.glitch.dtSize,
+      columns: typeof glitch?.columns === "number" && Number.isFinite(glitch.columns) ? glitch.columns : defaults.glitch.columns,
+      ratio: typeof glitch?.ratio === "number" && Number.isFinite(glitch.ratio) ? glitch.ratio : defaults.glitch.ratio,
+      mode: typeof glitch?.mode === "string" ? glitch.mode : defaults.glitch.mode,
+      active: toBoolean2(glitch?.active, false)
+    }
+  };
+}
+__name(normalizePostprocessing, "normalizePostprocessing");
+var _Postprocessing = class _Postprocessing extends Component {
+  constructor(values) {
+    super();
+    this.values = normalizePostprocessing(values);
+  }
+};
+__name(_Postprocessing, "Postprocessing");
+var Postprocessing = _Postprocessing;
+
+// 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/components/ScriptComponent.ts
+var _ScriptComponent = class _ScriptComponent extends Component {
+  constructor(entries = []) {
+    super();
+    this.entries = entries.map((entry) => ({
+      entityId: typeof entry.entityId === "number" ? entry.entityId : 0,
+      className: typeof entry.className === "string" ? entry.className : "",
+      scriptUrl: typeof entry.scriptUrl === "string" ? entry.scriptUrl : "",
+      enabled: typeof entry.enabled === "boolean" ? entry.enabled : true,
+      executeInEditor: typeof entry.executeInEditor === "boolean" ? entry.executeInEditor : false,
+      data: entry.data && typeof entry.data === "object" && !Array.isArray(entry.data) ? entry.data : {},
+      runtimeState: entry.runtimeState,
+      runtimeMessage: typeof entry.runtimeMessage === "string" ? entry.runtimeMessage : void 0
+    }));
+    Object.defineProperty(this, "scriptInstance", {
+      value: null,
+      writable: true,
+      configurable: true,
+      enumerable: false
+    });
+    Object.defineProperty(this, "scriptInstances", {
+      value: /* @__PURE__ */ new Map(),
+      writable: true,
+      configurable: true,
+      enumerable: false
+    });
+  }
+};
+__name(_ScriptComponent, "ScriptComponent");
+var ScriptComponent = _ScriptComponent;
+
+// core/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/components/Selectable.ts
+var _Selectable = class _Selectable extends Component {
+  constructor(enabled = true) {
+    super();
+    this.enabled = enabled;
+  }
+};
+__name(_Selectable, "Selectable");
+var Selectable = _Selectable;
+
+// 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/components/SelectionTransformState.ts
+var _SelectionTransformState = class _SelectionTransformState extends Component {
+  constructor(transform = "translate", space = "world", selectedEntityId = null) {
+    super();
+    this.transform = transform;
+    this.space = space;
+    this.selectedEntityId = selectedEntityId;
+  }
+};
+__name(_SelectionTransformState, "SelectionTransformState");
+var SelectionTransformState = _SelectionTransformState;
+
+// 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/components/Sprite.ts
+var _SpriteComponent = class _SpriteComponent extends Component {
+  constructor(path, width = 1, height = 1) {
+    super();
+    this.path = path;
+    this.width = width;
+    this.height = height;
+    this.texture = null;
+    this.object = null;
+  }
+};
+__name(_SpriteComponent, "SpriteComponent");
+var SpriteComponent = _SpriteComponent;
+
+// core/factories/components/SpriteFactory.ts
+function createSpriteComponent(world, entityId, ...args) {
+  const component = new SpriteComponent(...args);
+  world.addComponent(entityId, component);
+  return component;
+}
+__name(createSpriteComponent, "createSpriteComponent");
+function readXYZ(input) {
+  return {
+    x: input.x,
+    y: input.y,
+    z: input.z
+  };
+}
+__name(readXYZ, "readXYZ");
+var _TransformComponent = class _TransformComponent extends Component {
+  constructor(data = {}) {
+    super();
+    const position = data.position ?? {};
+    const rotation = data.rotation ?? {};
+    const scale = data.scale ?? {};
+    this.position = {
+      x: position.x ?? 0,
+      y: position.y ?? 0,
+      z: position.z ?? 0
+    };
+    this.rotation = {
+      x: rotation.x ?? 0,
+      y: rotation.y ?? 0,
+      z: rotation.z ?? 0
+    };
+    this.scale = {
+      x: scale.x ?? 1,
+      y: scale.y ?? 1,
+      z: scale.z ?? 1
+    };
+  }
+  toPositionVector3(target = new THREE26.Vector3()) {
+    return target.set(this.position.x, this.position.y, this.position.z);
+  }
+  toRotationEuler(target = new THREE26.Euler(), order = "XYZ") {
+    return target.set(this.rotation.x, this.rotation.y, this.rotation.z, order);
+  }
+  toRotationQuaternion(target = new THREE26.Quaternion(), order = "XYZ") {
+    const euler = new THREE26.Euler(
+      this.rotation.x,
+      this.rotation.y,
+      this.rotation.z,
+      order
+    );
+    return target.setFromEuler(euler);
+  }
+  toScaleVector3(target = new THREE26.Vector3()) {
+    return target.set(this.scale.x, this.scale.y, this.scale.z);
+  }
+  setPosition(input) {
+    const next = readXYZ(input);
+    this.position.x = next.x;
+    this.position.y = next.y;
+    this.position.z = next.z;
+    return this;
+  }
+  setScale(input) {
+    const next = readXYZ(input);
+    this.scale.x = next.x;
+    this.scale.y = next.y;
+    this.scale.z = next.z;
+    return this;
+  }
+  setRotation(input, order = "XYZ") {
+    if (input instanceof THREE26.Quaternion) {
+      const euler = new THREE26.Euler().setFromQuaternion(input, order);
+      this.rotation.x = euler.x;
+      this.rotation.y = euler.y;
+      this.rotation.z = euler.z;
+      return this;
+    }
+    const next = readXYZ(input);
+    this.rotation.x = next.x;
+    this.rotation.y = next.y;
+    this.rotation.z = next.z;
+    return this;
+  }
+};
+__name(_TransformComponent, "TransformComponent");
+var TransformComponent = _TransformComponent;
+
+// core/factories/components/TransformFactory.ts
+function createTransformComponent(world, entityId, ...args) {
+  const component = new TransformComponent(...args);
+  world.addComponent(entityId, component);
+  return component;
+}
+__name(createTransformComponent, "createTransformComponent");
+
+// core/components/Video.ts
+var DEFAULT_VIDEO_OPTIONS = {
+  autoplay: false,
+  loop: true,
+  volume: 1,
+  width: 1,
+  height: 1,
+  isGreenScreen: false,
+  backgroundColor: "#00ff00",
+  similarity: 0.4,
+  smoothness: 0.08,
+  spill: 0.12,
+  /** When `true`, the video's audio stream is spatialized using the entity's transform. */
+  positional: false,
+  /** Distance at which volume is unattenuated (positional only). */
+  refDistance: 1,
+  /** WebAudio distance model (`linear`, `inverse`, `exponential`). Positional only. */
+  distanceModel: "inverse",
+  /** How quickly volume falls off past `refDistance`. Positional only. */
+  rolloffFactor: 1
+};
+var _VideoComponent = class _VideoComponent extends Component {
+  constructor(path, options = {}) {
+    super();
+    this.path = path;
+    this.options = {
+      ...DEFAULT_VIDEO_OPTIONS,
+      ...options
+    };
+    this.object = null;
+    this.videoElement = null;
+    this.texture = null;
+    this.material = null;
+    this.audioNode = null;
+    Object.defineProperty(this, "isPlaying", {
+      value: false,
+      writable: true,
+      configurable: true,
+      enumerable: false
+    });
+    Object.defineProperty(this, "isPaused", {
+      value: false,
+      writable: true,
+      configurable: true,
+      enumerable: false
+    });
+  }
+  /**
+   * Signals `VideoSystem` to start (or resume) playback.
+   * Has no direct effect in the editor — `VideoSystem` drives the actual
+   * HTML video element call in preview.
+   */
+  play() {
+    this.isPlaying = true;
+    this.isPaused = false;
+  }
+  /**
+   * Signals `VideoSystem` to pause playback, preserving the current position.
+   * Calling {@link play} afterwards resumes from where it paused.
+   * No-op if not currently playing.
+   */
+  pause() {
+    if (!this.isPlaying) return;
+    this.isPlaying = false;
+    this.isPaused = true;
+  }
+  /**
+   * Signals `VideoSystem` to stop playback and reset the playback position.
+   */
+  stop() {
+    this.isPlaying = false;
+    this.isPaused = false;
+  }
+};
+__name(_VideoComponent, "VideoComponent");
+var VideoComponent = _VideoComponent;
+
+// core/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/registerDefaultComponentFactories.ts
+function registerDefaultComponentFactories(objectManagementSystem) {
+  objectManagementSystem.registerComponentFactory("animation", createAnimationComponent);
+  objectManagementSystem.registerComponentFactory("audio", createAudioComponent);
+  objectManagementSystem.registerComponentFactory("camera", createCameraComponent);
+  objectManagementSystem.registerComponentFactory("physics", createPhysicsComponent);
+  objectManagementSystem.registerComponentFactory("environment", createEnvironmentComponent);
+  objectManagementSystem.registerComponentFactory("entityType", createEntityTypeComponent);
+  objectManagementSystem.registerComponentFactory("image", createImageComponent);
+  objectManagementSystem.registerComponentFactory(
+    "imageTargetAnchor",
+    createImageTargetAnchorComponent
+  );
+  objectManagementSystem.registerComponentFactory("imageTarget", createImageTargetComponent);
+  objectManagementSystem.registerComponentFactory("light", createLightComponent);
+  objectManagementSystem.registerComponentFactory("material", createMaterialComponent);
+  objectManagementSystem.registerComponentFactory("mesh", createMeshComponent);
+  objectManagementSystem.registerComponentFactory(
+    "meshGeometry",
+    createMeshGeometryComponent
+  );
+  objectManagementSystem.registerComponentFactory("model", createModelComponent);
+  objectManagementSystem.registerComponentFactory("name", createNameComponent);
+  objectManagementSystem.registerComponentFactory(
+    "object3DRef",
+    createObject3DRefComponent
+  );
+  objectManagementSystem.registerComponentFactory("parentId", createParentIdComponent);
+  objectManagementSystem.registerComponentFactory(
+    "postprocessing",
+    createPostprocessingComponent
+  );
+  objectManagementSystem.registerComponentFactory("script", createScriptComponent);
+  objectManagementSystem.registerComponentFactory("selectable", createSelectableComponent);
+  objectManagementSystem.registerComponentFactory(
+    "selectionTransformState",
+    createSelectionTransformStateComponent
+  );
+  objectManagementSystem.registerComponentFactory("sprite", createSpriteComponent);
+  objectManagementSystem.registerComponentFactory("transform", createTransformComponent);
+  objectManagementSystem.registerComponentFactory("video", createVideoComponent);
+}
+__name(registerDefaultComponentFactories, "registerDefaultComponentFactories");
+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");
+
+// 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/AudioFactory.ts
+function getOrCreateListener(camera) {
+  const existing = camera.userData.ecsAudioListener;
+  if (existing instanceof THREE26__namespace.AudioListener) {
+    return existing;
+  }
+  const listener = new THREE26__namespace.AudioListener();
+  camera.add(listener);
+  camera.userData.ecsAudioListener = listener;
+  return listener;
+}
+__name(getOrCreateListener, "getOrCreateListener");
+function createAudio({
+  world,
+  scene,
+  camera,
+  payload,
+  isEditor
+}) {
+  const anchor = new THREE26__namespace.Object3D();
+  const entityId = createBaseEntity(world, anchor, {
+    label: payload.name ?? "Audio",
+    entityType: "audio",
+    transformInput: payload.transform
+  });
+  const audio = createAudioComponent(
+    world,
+    entityId,
+    payload.path ?? "",
+    payload.options ?? {},
+    {
+      object: anchor,
+      listener: getOrCreateListener(camera),
+      isEditor
+    }
+  );
+  scene.add(anchor);
+  if (!audio.path) {
+    return entityId;
+  }
+  if (!isEditor) {
+    const loader = new THREE26__namespace.AudioLoader();
+    loader.load(
+      audio.path,
+      (buffer) => {
+        if (!world.hasEntity(entityId)) {
+          return;
+        }
+        const sound = audio.audio;
+        if (!sound) {
+          return;
+        }
+        sound.setBuffer(buffer);
+        if (audio.options.autoplay) {
+          audio.play();
+        }
+      },
+      void 0,
+      (error) => {
+        console.error(`Failed to load audio: ${audio.path}`, error);
+      }
+    );
+  }
+  return entityId;
+}
+__name(createAudio, "createAudio");
+var DEFAULT_NEAR2 = 0.1;
+var DEFAULT_FAR2 = 2e3;
+var DEFAULT_FOV2 = 50;
+var DEFAULT_ORTHOGRAPHIC_HALF_HEIGHT = 5;
+function readViewportAspect() {
+  if (typeof window === "undefined") {
+    return 1;
+  }
+  const width = window.innerWidth;
+  const height = window.innerHeight;
+  if (Number.isFinite(width) && Number.isFinite(height) && width > 0 && height > 0) {
+    return width / height;
+  }
+  return 1;
+}
+__name(readViewportAspect, "readViewportAspect");
+function toCameraCreateOptions(input) {
+  if (!input || typeof input !== "object") {
+    return {};
+  }
+  const value = input;
+  const type = value.type === "3d" || value.type === "ar" ? value.type : void 0;
+  const projection = value.projection === "orthographic" || value.projection === "perspective" ? value.projection : void 0;
+  return {
+    type,
+    isDefault: typeof value.isDefault === "boolean" ? value.isDefault : void 0,
+    projection,
+    fov: typeof value.fov === "number" && Number.isFinite(value.fov) ? value.fov : void 0,
+    near: typeof value.near === "number" && Number.isFinite(value.near) ? value.near : void 0,
+    far: typeof value.far === "number" && Number.isFinite(value.far) ? value.far : void 0,
+    left: typeof value.left === "number" && Number.isFinite(value.left) ? value.left : void 0,
+    right: typeof value.right === "number" && Number.isFinite(value.right) ? value.right : void 0,
+    top: typeof value.top === "number" && Number.isFinite(value.top) ? value.top : void 0,
+    bottom: typeof value.bottom === "number" && Number.isFinite(value.bottom) ? value.bottom : void 0,
+    zoom: typeof value.zoom === "number" && Number.isFinite(value.zoom) ? value.zoom : void 0
+  };
+}
+__name(toCameraCreateOptions, "toCameraCreateOptions");
+function resolveCameraCreateOptions(payload) {
+  const next = toCameraCreateOptions(payload.options);
+  if (payload.options && typeof payload.options === "object") {
+    return next;
+  }
+  return toCameraCreateOptions(payload.camera);
+}
+__name(resolveCameraCreateOptions, "resolveCameraCreateOptions");
+function applyCameraSettings(camera, options) {
+  const near = typeof options.near === "number" ? options.near : DEFAULT_NEAR2;
+  const far = typeof options.far === "number" ? options.far : DEFAULT_FAR2;
+  const projection = options.projection;
+  if (camera instanceof THREE26__namespace.PerspectiveCamera) {
+    if (!projection || projection === "perspective") {
+      camera.fov = typeof options.fov === "number" ? options.fov : DEFAULT_FOV2;
+    }
+    camera.aspect = readViewportAspect();
+    camera.near = near;
+    camera.far = far;
+    camera.updateProjectionMatrix();
+    return;
+  }
+  if (camera instanceof THREE26__namespace.OrthographicCamera) {
+    camera.left = typeof options.left === "number" ? options.left : -DEFAULT_ORTHOGRAPHIC_HALF_HEIGHT;
+    camera.right = typeof options.right === "number" ? options.right : DEFAULT_ORTHOGRAPHIC_HALF_HEIGHT;
+    camera.top = typeof options.top === "number" ? options.top : DEFAULT_ORTHOGRAPHIC_HALF_HEIGHT;
+    camera.bottom = typeof options.bottom === "number" ? options.bottom : -DEFAULT_ORTHOGRAPHIC_HALF_HEIGHT;
+    camera.zoom = typeof options.zoom === "number" ? options.zoom : 1;
+    camera.near = near;
+    camera.far = far;
+    camera.updateProjectionMatrix();
+  }
+}
+__name(applyCameraSettings, "applyCameraSettings");
+function createCameraObject(options) {
+  const projection = options.projection ?? "perspective";
+  const near = options.near ?? DEFAULT_NEAR2;
+  const far = options.far ?? DEFAULT_FAR2;
+  if (projection === "orthographic") {
+    const top = options.top ?? DEFAULT_ORTHOGRAPHIC_HALF_HEIGHT;
+    const bottom = options.bottom ?? -DEFAULT_ORTHOGRAPHIC_HALF_HEIGHT;
+    const left = options.left ?? -DEFAULT_ORTHOGRAPHIC_HALF_HEIGHT;
+    const right = options.right ?? DEFAULT_ORTHOGRAPHIC_HALF_HEIGHT;
+    const camera = new THREE26__namespace.OrthographicCamera(
+      left,
+      right,
+      top,
+      bottom,
+      near,
+      far
+    );
+    camera.zoom = options.zoom ?? 1;
+    camera.updateProjectionMatrix();
+    return camera;
+  }
+  return new THREE26__namespace.PerspectiveCamera(
+    options.fov ?? DEFAULT_FOV2,
+    readViewportAspect(),
+    near,
+    far
+  );
+}
+__name(createCameraObject, "createCameraObject");
+function createCamera({ world, scene, camera, payload, isEditor }) {
+  const options = resolveCameraCreateOptions(payload);
+  const useWorldCamera = !isEditor && (payload.useWorldCamera === true || Boolean(options.isDefault));
+  const object = useWorldCamera ? camera : createCameraObject(options);
+  const entityId = createBaseEntity(world, object, {
+    label: payload.name ?? "Camera",
+    entityType: "camera",
+    transformInput: payload.transform
+  });
+  const objectRef = world.getComponent(entityId, Object3DRef);
+  if (objectRef?.object instanceof THREE26__namespace.Camera) {
+    objectRef.object.userData.entityId = entityId;
+  }
+  const componentOptions = {
+    camera: object,
+    type: options.type,
+    isDefault: options.isDefault,
+    projection: options.projection,
+    fov: options.fov,
+    near: options.near,
+    far: options.far,
+    left: options.left,
+    right: options.right,
+    top: options.top,
+    bottom: options.bottom,
+    zoom: options.zoom
+  };
+  const component = createCameraComponent(world, entityId, componentOptions);
+  if (useWorldCamera) {
+    applyCameraSettings(object, options);
+  } else {
+    applyCameraSettings(object, options);
+    if (isEditor && component.isDefault) {
+      const helper = new THREE26__namespace.CameraHelper(object);
+      helper.onBeforeRender = () => {
+        helper.update();
+      };
+      helper.userData.ecsHelper = true;
+      helper.visible = false;
+      object.add(helper);
+    }
+    scene.add(object);
+  }
+  return entityId;
+}
+__name(createCamera, "createCamera");
+function createCapsule({
+  world,
+  scene,
+  payload
+}) {
+  const geometry = new THREE26__namespace.CapsuleGeometry(0.5, 1, 4, 8);
+  const material = new THREE26__namespace.MeshStandardMaterial({ color: "#ffffff" });
+  const mesh = new THREE26__namespace.Mesh(geometry, material);
+  const entityId = createBaseEntity(world, mesh, {
+    label: payload.name ?? "Capsule",
+    entityType: "capsule",
+    transformInput: payload.transform
+  });
+  createMeshComponent(world, entityId, mesh);
+  createMaterialComponent(world, entityId, material);
+  createMeshGeometryComponent(world, entityId, "capsule", mesh, {
+    radius: 0.5,
+    height: 1
+  }, {
+    castShadow: false,
+    receiveShadow: false
+  });
+  scene.add(mesh);
+  return entityId;
+}
+__name(createCapsule, "createCapsule");
+function createCube({ world, scene, payload }) {
+  const geometry = new THREE26__namespace.BoxGeometry(1, 1, 1);
+  const material = new THREE26__namespace.MeshStandardMaterial({ color: "#ffffff" });
+  const mesh = new THREE26__namespace.Mesh(geometry, material);
+  const entityId = createBaseEntity(world, mesh, {
+    label: payload.name ?? "Cube",
+    entityType: "cube",
+    transformInput: payload.transform
+  });
+  createMeshComponent(world, entityId, mesh);
+  createMaterialComponent(world, entityId, material);
+  createMeshGeometryComponent(world, entityId, "cube", mesh, {
+    width: 1,
+    height: 1,
+    depth: 1
+  }, {
+    castShadow: false,
+    receiveShadow: false
+  });
+  scene.add(mesh);
+  return entityId;
+}
+__name(createCube, "createCube");
+function createCylinder({
+  world,
+  scene,
+  payload
+}) {
+  const geometry = new THREE26__namespace.CylinderGeometry(0.5, 0.5, 1, 20);
+  const material = new THREE26__namespace.MeshStandardMaterial({ color: "#ffffff" });
+  const mesh = new THREE26__namespace.Mesh(geometry, material);
+  const entityId = createBaseEntity(world, mesh, {
+    label: payload.name ?? "Cylinder",
+    entityType: "cylinder",
+    transformInput: payload.transform
+  });
+  createMeshComponent(world, entityId, mesh);
+  createMaterialComponent(world, entityId, material);
+  createMeshGeometryComponent(world, entityId, "cylinder", mesh, {
+    radius: 0.5,
+    height: 1
+  }, {
+    castShadow: false,
+    receiveShadow: false
+  });
+  scene.add(mesh);
+  return entityId;
+}
+__name(createCylinder, "createCylinder");
+function createEmpty({ world, scene, payload, isEditor }) {
+  const object = new THREE26__namespace.Group();
+  const entityId = createBaseEntity(world, object, {
+    label: payload.name ?? "Empty",
+    entityType: "empty",
+    transformInput: payload.transform
+  });
+  scene.add(object);
+  return entityId;
+}
+__name(createEmpty, "createEmpty");
+function createImage({ world, scene, payload }) {
+  const anchor = new THREE26__namespace.Object3D();
+  const imagePath = payload.path ?? "";
+  const entityId = createBaseEntity(world, anchor, {
+    label: payload.name ?? "Image",
+    entityType: "image",
+    transformInput: payload.transform
+  });
+  const image = createImageComponent(world, entityId, imagePath);
+  image.object = anchor;
+  scene.add(anchor);
+  if (!imagePath) {
+    return entityId;
+  }
+  const loader = new THREE26__namespace.TextureLoader();
+  loader.load(
+    imagePath,
+    (texture) => {
+      if (!world.hasEntity(entityId)) {
+        texture.dispose();
+        return;
+      }
+      const material = new THREE26__namespace.MeshBasicMaterial({
+        map: texture,
+        transparent: true,
+        side: THREE26__namespace.DoubleSide
+      });
+      const geometry = new THREE26__namespace.PlaneGeometry(1, 1);
+      const plane = new THREE26__namespace.Mesh(geometry, material);
+      plane.userData.entityId = entityId;
+      const textureImage = texture.image;
+      const width = textureImage?.width ?? 1;
+      const height = textureImage?.height ?? 1;
+      const aspect = height > 0 ? width / height : 1;
+      image.width = width;
+      image.height = height;
+      plane.scale.set(aspect, 1, 1);
+      anchor.add(plane);
+      image.texture = texture;
+      image.object = plane;
+    },
+    void 0,
+    (error) => {
+      console.error(`Failed to load image: ${imagePath}`, error);
+    }
+  );
+  return entityId;
+}
+__name(createImage, "createImage");
+function toImageTargetOptions(input) {
+  if (!input || typeof input !== "object") {
+    return {};
+  }
+  const value = input;
+  const targets = Array.isArray(value.targets) ? value.targets.filter((target) => {
+    if (!target || typeof target !== "object") {
+      return false;
+    }
+    const candidate = target;
+    return typeof candidate.id === "number" && Number.isFinite(candidate.id) && typeof candidate.url === "string" && candidate.url.length > 0 && typeof candidate.width === "number" && Number.isFinite(candidate.width) && typeof candidate.height === "number" && Number.isFinite(candidate.height);
+  }) : void 0;
+  return {
+    targets,
+    compiledTargetUrl: typeof value.compiledTargetUrl === "string" ? value.compiledTargetUrl : void 0,
+    compiledTargetDir: typeof value.compiledTargetDir === "string" ? value.compiledTargetDir : void 0
+  };
+}
+__name(toImageTargetOptions, "toImageTargetOptions");
+function createImageTarget({
+  world,
+  scene,
+  payload,
+  isEditor
+}) {
+  const anchor = new THREE26__namespace.Object3D();
+  const imagePath = payload.path ?? "";
+  const entityId = createBaseEntity(world, anchor, {
+    label: payload.name ?? "Image Target",
+    entityType: "imageTarget",
+    transformInput: payload.transform
+  });
+  const targetOptions = toImageTargetOptions(payload.options);
+  const imageTarget = createImageTargetComponent(
+    world,
+    entityId,
+    targetOptions
+  );
+  scene.add(anchor);
+  if (!isEditor || !imagePath) {
+    return entityId;
+  }
+  const loader = new THREE26__namespace.TextureLoader();
+  loader.load(
+    imagePath,
+    (texture) => {
+      if (!world.hasEntity(entityId)) {
+        texture.dispose();
+        return;
+      }
+      const material = new THREE26__namespace.MeshBasicMaterial({
+        map: texture,
+        transparent: true,
+        side: THREE26__namespace.DoubleSide
+      });
+      const geometry = new THREE26__namespace.PlaneGeometry(1, 1);
+      const plane = new THREE26__namespace.Mesh(geometry, material);
+      plane.userData.entityId = entityId;
+      const textureImage = texture.image;
+      const width = textureImage?.width ?? 1;
+      const height = textureImage?.height ?? 1;
+      const aspect = height > 0 ? width / height : 1;
+      plane.scale.set(aspect, 1, 1);
+      anchor.add(plane);
+      imageTarget.texture = texture;
+      imageTarget.object = plane;
+    },
+    void 0,
+    (error) => {
+      console.error(`Failed to load image target: ${imagePath}`, error);
+    }
+  );
+  return entityId;
+}
+__name(createImageTarget, "createImageTarget");
+function createAmbientLight({
+  world,
+  scene,
+  payload
+}) {
+  const light = new THREE26__namespace.AmbientLight("#ffffff", 0.6);
+  const entityId = createBaseEntity(world, light, {
+    label: payload.name ?? "Ambient Light",
+    entityType: "ambientLight",
+    transformInput: payload.transform
+  });
+  createLightComponent(world, entityId, light);
+  scene.add(light);
+  return entityId;
+}
+__name(createAmbientLight, "createAmbientLight");
+function createAreaLight({
+  world,
+  scene,
+  payload,
+  isEditor
+}) {
+  const light = new THREE26__namespace.RectAreaLight("#ffffff", 5, 4, 4);
+  light.lookAt(0, 0, 0);
+  const entityId = createBaseEntity(world, light, {
+    label: payload.name ?? "Area Light",
+    entityType: "areaLight",
+    transformInput: payload.transform ?? {
+      position: { x: 0, y: 4, z: 0 }
+    }
+  });
+  createLightComponent(world, entityId, light);
+  if (isEditor) {
+    const helper = new RectAreaLightHelper_js.RectAreaLightHelper(light, "#fb7185");
+    helper.onBeforeRender = () => {
+      helper.updateMatrixWorld(true);
+    };
+    helper.userData.ecsHelper = true;
+    helper.visible = false;
+    light.add(helper);
+  }
+  scene.add(light);
+  return entityId;
+}
+__name(createAreaLight, "createAreaLight");
+function createDirectionalLight({
+  world,
+  scene,
+  payload,
+  isEditor
+}) {
+  const light = new THREE26__namespace.DirectionalLight("#ffffff", 1.5);
+  light.castShadow = true;
+  const entityId = createBaseEntity(world, light, {
+    label: payload.name ?? "Directional Light",
+    entityType: "directionalLight",
+    transformInput: payload.transform ?? {
+      position: { x: 3, y: 6, z: 4 }
+    }
+  });
+  createLightComponent(world, entityId, light);
+  if (isEditor) {
+    const helper = new THREE26__namespace.DirectionalLightHelper(light, 1.8, "#38bdf8");
+    helper.onBeforeRender = () => {
+      helper.update();
+    };
+    helper.userData.ecsHelper = true;
+    helper.visible = false;
+    light.add(helper);
+  }
+  scene.add(light);
+  return entityId;
+}
+__name(createDirectionalLight, "createDirectionalLight");
+function createPointLight({
+  world,
+  scene,
+  payload,
+  isEditor
+}) {
+  const light = new THREE26__namespace.PointLight("#ffffff", 1, 10);
+  const entityId = createBaseEntity(world, light, {
+    label: payload.name ?? "Point Light",
+    entityType: "pointLight",
+    transformInput: payload.transform ?? {
+      position: { x: 2, y: 3, z: 2 }
+    }
+  });
+  createLightComponent(world, entityId, light);
+  if (isEditor) {
+    const helper = new THREE26__namespace.PointLightHelper(light, 0.35, "#fbbf24");
+    helper.onBeforeRender = () => {
+      helper.update();
+    };
+    helper.userData.ecsHelper = true;
+    helper.visible = false;
+    light.add(helper);
+  }
+  scene.add(light);
+  return entityId;
+}
+__name(createPointLight, "createPointLight");
+function createSpotLight({
+  world,
+  scene,
+  payload,
+  isEditor
+}) {
+  const light = new THREE26__namespace.SpotLight("#ffffff", 1, 20, Math.PI / 6, 0.1, 1);
+  const entityId = createBaseEntity(world, light, {
+    label: payload.name ?? "Spot Light",
+    entityType: "spotLight",
+    transformInput: payload.transform ?? {
+      position: { x: 2, y: 5, z: 2 }
+    }
+  });
+  createLightComponent(world, entityId, light);
+  if (isEditor) {
+    const helper = new THREE26__namespace.SpotLightHelper(light, "#f59e0b");
+    helper.onBeforeRender = () => {
+      helper.update();
+    };
+    helper.userData.ecsHelper = true;
+    helper.visible = false;
+    light.add(helper);
+  }
+  scene.add(light);
+  return entityId;
+}
+__name(createSpotLight, "createSpotLight");
+
+// 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/";
+function isBlockedBrowserFileUrl(url) {
+  return url.startsWith("file://");
+}
+__name(isBlockedBrowserFileUrl, "isBlockedBrowserFileUrl");
+function resolveDracoDecoderPath() {
+  try {
+    const resolvedPath = new URL(
+      LOCAL_DRACO_DECODER_RELATIVE_PATH,
+      (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href))
+    ).toString();
+    if (isBlockedBrowserFileUrl(resolvedPath)) {
+      return DRACO_DECODER_CDN_PATH;
+    }
+    return resolvedPath;
+  } catch {
+    return DRACO_DECODER_CDN_PATH;
+  }
+}
+__name(resolveDracoDecoderPath, "resolveDracoDecoderPath");
+
+// core/factories/objects/ModelFactory.ts
+var DEFAULT_DRACO_DECODER_PATH = resolveDracoDecoderPath();
+function getModelFileName(path) {
+  const segments = path.split(/[\\/]/).filter(Boolean);
+  return segments[segments.length - 1] ?? "";
+}
+__name(getModelFileName, "getModelFileName");
+function createModelLoader() {
+  const loader = new GLTFLoader_js.GLTFLoader();
+  try {
+    const dracoLoader = new DRACOLoader_js.DRACOLoader();
+    dracoLoader.setDecoderPath(DEFAULT_DRACO_DECODER_PATH);
+    loader.setDRACOLoader(dracoLoader);
+  } catch (error) {
+    console.warn("DRACOLoader could not be configured. Loading non-Draco models only.", error);
+  }
+  return loader;
+}
+__name(createModelLoader, "createModelLoader");
+function createModel({ world, scene, payload }) {
+  const anchor = new THREE26__namespace.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);
+  const meshGeometry = createMeshGeometryComponent(world, entityId, "model", anchor, {}, {
+    modelName: getModelFileName(modelPath),
+    castShadow: false,
+    receiveShadow: false
+  });
+  model.object = anchor;
+  scene.add(anchor);
+  if (!modelPath) {
+    return entityId;
+  }
+  const loader = createModelLoader();
+  loader.load(
+    modelPath,
+    (gltf) => {
+      if (!world.hasEntity(entityId)) {
+        return;
+      }
+      const object = gltf.scene;
+      object.userData.entityId = entityId;
+      object.traverse((child) => {
+        child.userData.entityId = entityId;
+      });
+      anchor.add(object);
+      model.object = object;
+      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);
+      }
+    },
+    void 0,
+    (error) => {
+      console.error(`Failed to load model: ${modelPath}`, error);
+    }
+  );
+  return entityId;
+}
+__name(createModel, "createModel");
+function createPlane({ world, scene, payload }) {
+  const geometry = new THREE26__namespace.PlaneGeometry(100, 100);
+  const material = new THREE26__namespace.MeshStandardMaterial({
+    color: "#ffffff",
+    side: THREE26__namespace.DoubleSide
+  });
+  const mesh = new THREE26__namespace.Mesh(geometry, material);
+  const entityId = createBaseEntity(
+    world,
+    mesh,
+    {
+      label: payload.name ?? "Plane",
+      entityType: "plane",
+      transformInput: {
+        position: payload.transform?.position,
+        rotation: payload.transform?.rotation ?? {
+          x: -Math.PI / 2,
+          y: 0,
+          z: 0
+        },
+        scale: payload.transform?.scale
+      }
+    }
+  );
+  createMeshComponent(world, entityId, mesh);
+  createMaterialComponent(world, entityId, material);
+  createMeshGeometryComponent(world, entityId, "plane", mesh, {
+    width: 10,
+    height: 10
+  }, {
+    castShadow: false,
+    receiveShadow: false
+  });
+  scene.add(mesh);
+  return entityId;
+}
+__name(createPlane, "createPlane");
+function createSprite({ world, scene, payload }) {
+  const anchor = new THREE26__namespace.Object3D();
+  const imagePath = payload.path ?? "";
+  const entityId = createBaseEntity(world, anchor, {
+    label: payload.name ?? "Sprite",
+    entityType: "sprite",
+    transformInput: payload.transform
+  });
+  const spriteComponent = createSpriteComponent(world, entityId, imagePath);
+  scene.add(anchor);
+  if (!imagePath) {
+    return entityId;
+  }
+  const loader = new THREE26__namespace.TextureLoader();
+  loader.load(
+    imagePath,
+    (texture) => {
+      if (!world.hasEntity(entityId)) {
+        texture.dispose();
+        return;
+      }
+      const material = new THREE26__namespace.SpriteMaterial({
+        map: texture,
+        transparent: true
+      });
+      const sprite = new THREE26__namespace.Sprite(material);
+      sprite.userData.entityId = entityId;
+      const textureImage = texture.image;
+      spriteComponent.width = textureImage?.width ?? 1;
+      spriteComponent.height = textureImage?.height ?? 1;
+      anchor.add(sprite);
+      spriteComponent.texture = texture;
+      spriteComponent.object = sprite;
+    },
+    void 0,
+    (error) => {
+      console.error(`Failed to load sprite: ${imagePath}`, error);
+    }
+  );
+  return entityId;
+}
+__name(createSprite, "createSprite");
+function createSphere({ world, scene, payload }) {
+  const geometry = new THREE26__namespace.SphereGeometry(0.5, 24, 24);
+  const material = new THREE26__namespace.MeshStandardMaterial({ color: "#ffffff" });
+  const mesh = new THREE26__namespace.Mesh(geometry, material);
+  const entityId = createBaseEntity(world, mesh, {
+    label: payload.name ?? "Sphere",
+    entityType: "sphere",
+    transformInput: payload.transform
+  });
+  createMeshComponent(world, entityId, mesh);
+  createMaterialComponent(world, entityId, material);
+  createMeshGeometryComponent(world, entityId, "sphere", mesh, {
+    radius: 0.5
+  }, {
+    castShadow: false,
+    receiveShadow: false
+  });
+  scene.add(mesh);
+  return entityId;
+}
+__name(createSphere, "createSphere");
+function getOrCreateListener2(camera) {
+  const existing = camera.userData.ecsAudioListener;
+  if (existing instanceof THREE26__namespace.AudioListener) {
+    return existing;
+  }
+  const listener = new THREE26__namespace.AudioListener();
+  camera.add(listener);
+  camera.userData.ecsAudioListener = listener;
+  return listener;
+}
+__name(getOrCreateListener2, "getOrCreateListener");
+function normalizeDistanceModel2(value) {
+  const v = value.trim().toLowerCase();
+  if (v === "linear" || v === "exponential") return v;
+  return "inverse";
+}
+__name(normalizeDistanceModel2, "normalizeDistanceModel");
+function toBool(value, fallback) {
+  return typeof value === "boolean" ? value : fallback;
+}
+__name(toBool, "toBool");
+function toNumber(value, fallback) {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    return fallback;
+  }
+  return value;
+}
+__name(toNumber, "toNumber");
+function toColor(value, fallback) {
+  if (typeof value !== "string" || value.trim().length === 0) {
+    return fallback;
+  }
+  return value;
+}
+__name(toColor, "toColor");
+function normalizeOptions(input) {
+  return {
+    autoplay: toBool(input?.autoplay, false),
+    loop: toBool(input?.loop, true),
+    volume: Math.max(0, Math.min(1, toNumber(input?.volume, 1))),
+    width: Math.max(0.01, toNumber(input?.width, 1)),
+    height: Math.max(0.01, toNumber(input?.height, 1)),
+    isGreenScreen: toBool(input?.isGreenScreen, false),
+    backgroundColor: toColor(input?.backgroundColor, "#00ff00"),
+    similarity: Math.max(0.01, Math.min(1, toNumber(input?.similarity, 0.4))),
+    smoothness: Math.max(1e-3, Math.min(1, toNumber(input?.smoothness, 0.08))),
+    spill: Math.max(0, Math.min(1, toNumber(input?.spill, 0.12))),
+    positional: toBool(input?.positional, false),
+    refDistance: Math.max(0, toNumber(input?.refDistance, 1)),
+    distanceModel: toColor(input?.distanceModel, "inverse"),
+    rolloffFactor: Math.max(0, toNumber(input?.rolloffFactor, 1))
+  };
+}
+__name(normalizeOptions, "normalizeOptions");
+function createChromaMaterial(texture, options) {
+  return new THREE26__namespace.ShaderMaterial({
+    uniforms: {
+      tex: { value: texture },
+      keyColor: { value: new THREE26__namespace.Color(options.backgroundColor) },
+      similarity: { value: options.similarity },
+      smoothness: { value: options.smoothness },
+      spill: { value: options.spill }
+    },
+    vertexShader: `
+      varying vec2 vUv;
+      void main() {
+        vUv = uv;
+        gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
+      }
+    `,
+    fragmentShader: `
+      uniform sampler2D tex;
+      uniform vec3 keyColor;
+      uniform float similarity;
+      uniform float smoothness;
+      uniform float spill;
+      varying vec2 vUv;
+
+      void main() {
+        vec4 texel = texture2D(tex, vUv);
+        float chromaDist = distance(texel.rgb, keyColor);
+        float alpha = smoothstep(similarity, similarity + smoothness, chromaDist);
+
+        float spillFactor = smoothstep(similarity, similarity + spill + smoothness, chromaDist);
+        vec3 despilled = mix(vec3(dot(texel.rgb, vec3(0.299, 0.587, 0.114))), texel.rgb, spillFactor);
+
+        gl_FragColor = vec4(despilled, texel.a * alpha);
+      }
+    `,
+    transparent: true,
+    side: THREE26__namespace.DoubleSide
+  });
+}
+__name(createChromaMaterial, "createChromaMaterial");
+function createStandardMaterial(texture) {
+  return new THREE26__namespace.MeshBasicMaterial({
+    map: texture,
+    transparent: true,
+    side: THREE26__namespace.DoubleSide
+  });
+}
+__name(createStandardMaterial, "createStandardMaterial");
+function createVideoMesh(entityId, texture, options) {
+  const geometry = new THREE26__namespace.PlaneGeometry(1, 1);
+  const material = options.isGreenScreen ? createChromaMaterial(texture, options) : createStandardMaterial(texture);
+  const mesh = new THREE26__namespace.Mesh(geometry, material);
+  mesh.userData.entityId = entityId;
+  mesh.scale.set(options.width, options.height, 1);
+  return { mesh, material };
+}
+__name(createVideoMesh, "createVideoMesh");
+function applyMetadataSizing(video, mesh, options) {
+  const width = video.videoWidth;
+  const height = video.videoHeight;
+  if (width <= 0 || height <= 0) {
+    return;
+  }
+  const nextWidth = options.width > 0 ? options.width : width / height;
+  const nextHeight = options.height > 0 ? options.height : 1;
+  mesh.scale.set(nextWidth, nextHeight, 1);
+}
+__name(applyMetadataSizing, "applyMetadataSizing");
+function createVideoElement(path, options) {
+  const video = document.createElement("video");
+  video.src = path;
+  video.crossOrigin = "anonymous";
+  video.loop = options.loop;
+  video.playsInline = true;
+  video.preload = "auto";
+  video.volume = options.volume;
+  return video;
+}
+__name(createVideoElement, "createVideoElement");
+function createVideo({
+  world,
+  scene,
+  camera,
+  payload,
+  isEditor
+}) {
+  const anchor = new THREE26__namespace.Object3D();
+  const path = payload.path ?? "";
+  const options = normalizeOptions(payload.options);
+  const entityId = createBaseEntity(world, anchor, {
+    label: payload.name ?? "Video",
+    entityType: "video",
+    transformInput: payload.transform
+  });
+  const videoComponent = createVideoComponent(world, entityId, path, options);
+  videoComponent.object = anchor;
+  scene.add(anchor);
+  if (!path || typeof document === "undefined") {
+    return entityId;
+  }
+  const video = createVideoElement(path, options);
+  const texture = new THREE26__namespace.VideoTexture(video);
+  texture.colorSpace = THREE26__namespace.SRGBColorSpace;
+  texture.needsUpdate = true;
+  const { mesh, material } = createVideoMesh(entityId, texture, options);
+  anchor.add(mesh);
+  videoComponent.videoElement = video;
+  videoComponent.texture = texture;
+  videoComponent.material = material;
+  videoComponent.object = mesh;
+  video.addEventListener("loadedmetadata", () => {
+    if (!world.hasEntity(entityId)) {
+      return;
+    }
+    applyMetadataSizing(video, mesh, options);
+  });
+  if (!isEditor && options.positional) {
+    const listener = getOrCreateListener2(camera);
+    const audioNode = new THREE26__namespace.PositionalAudio(listener);
+    audioNode.setVolume(options.volume);
+    audioNode.setRefDistance(options.refDistance);
+    audioNode.setDistanceModel(normalizeDistanceModel2(options.distanceModel));
+    audioNode.setRolloffFactor(options.rolloffFactor);
+    audioNode.setMediaElementSource(video);
+    video.volume = 1;
+    anchor.add(audioNode);
+    videoComponent.audioNode = audioNode;
+  }
+  if (options.autoplay) {
+    videoComponent.play();
+  }
+  return entityId;
+}
+__name(createVideo, "createVideo");
+
+// core/factories/registerDefaultFactories.ts
+function registerDefaultFactories(objectManagementSystem) {
+  objectManagementSystem.register("cube", createCube);
+  objectManagementSystem.register("sphere", createSphere);
+  objectManagementSystem.register("plane", createPlane);
+  objectManagementSystem.register("capsule", createCapsule);
+  objectManagementSystem.register("cylinder", createCylinder);
+  objectManagementSystem.register("empty", createEmpty);
+  objectManagementSystem.register("model", createModel);
+  objectManagementSystem.register("image", createImage);
+  objectManagementSystem.register("imageTarget", createImageTarget);
+  objectManagementSystem.register("sprite", createSprite);
+  objectManagementSystem.register("audio", createAudio);
+  objectManagementSystem.register("camera", createCamera);
+  objectManagementSystem.register("video", createVideo);
+  objectManagementSystem.register("ambientLight", createAmbientLight);
+  objectManagementSystem.register("directionalLight", createDirectionalLight);
+  objectManagementSystem.register("pointLight", createPointLight);
+  objectManagementSystem.register("spotLight", createSpotLight);
+  objectManagementSystem.register("areaLight", createAreaLight);
+  registerDefaultComponentFactories(objectManagementSystem);
+}
+__name(registerDefaultFactories, "registerDefaultFactories");
+
+exports.createAnimationComponent = createAnimationComponent;
+exports.createAudioComponent = createAudioComponent;
+exports.createCameraComponent = createCameraComponent;
+exports.createEntityTypeComponent = createEntityTypeComponent;
+exports.createEnvironmentComponent = createEnvironmentComponent;
+exports.createImageComponent = createImageComponent;
+exports.createImageTargetAnchorComponent = createImageTargetAnchorComponent;
+exports.createImageTargetComponent = createImageTargetComponent;
+exports.createLightComponent = createLightComponent;
+exports.createMaterialComponent = createMaterialComponent;
+exports.createMeshComponent = createMeshComponent;
+exports.createMeshGeometryComponent = createMeshGeometryComponent;
+exports.createModelComponent = createModelComponent;
+exports.createNameComponent = createNameComponent;
+exports.createObject3DRefComponent = createObject3DRefComponent;
+exports.createParentIdComponent = createParentIdComponent;
+exports.createPhysicsComponent = createPhysicsComponent;
+exports.createPostprocessingComponent = createPostprocessingComponent;
+exports.createScriptComponent = createScriptComponent;
+exports.createSelectableComponent = createSelectableComponent;
+exports.createSelectionTransformStateComponent = createSelectionTransformStateComponent;
+exports.createSpriteComponent = createSpriteComponent;
+exports.createTransformComponent = createTransformComponent;
+exports.createVideoComponent = createVideoComponent;
+exports.registerDefaultComponentFactories = registerDefaultComponentFactories;
+exports.registerDefaultFactories = registerDefaultFactories;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map