@relu-interactives/spatial-ecs 0.2.2

package/dist/components/index.cjs

@@ -0,0 +1,1745 @@
+'use strict';
+
+var THREE4 = require('three');
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var THREE4__namespace = /*#__PURE__*/_interopNamespace(THREE4);
+
+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 THREE4__namespace.AnimationClip) {
+        return { clip: entry, sourceUrl: null };
+      }
+      if (!entry || typeof entry !== "object") {
+        return null;
+      }
+      const candidate = entry;
+      if (!(candidate.clip instanceof THREE4__namespace.AnimationClip)) {
+        return null;
+      }
+      return {
+        clip: candidate.clip,
+        sourceUrl: typeof candidate.sourceUrl === "string" && candidate.sourceUrl.length > 0 ? candidate.sourceUrl : null
+      };
+    }).filter((entry) => entry !== null);
+    this.refreshClipCatalog();
+  }
+  setExternalClipSources(sources) {
+    if (!Array.isArray(sources)) {
+      this.externalClipSources = [];
+      return;
+    }
+    const seen = /* @__PURE__ */ new Set();
+    const normalized = [];
+    for (const source of sources) {
+      if (typeof source !== "string") {
+        continue;
+      }
+      const trimmed = source.trim();
+      if (!trimmed || seen.has(trimmed)) {
+        continue;
+      }
+      seen.add(trimmed);
+      normalized.push(trimmed);
+    }
+    this.externalClipSources = normalized;
+  }
+  addState(name, clipRef, loop = false) {
+    if (!name.trim()) {
+      return null;
+    }
+    const resolved = this.resolveClipRef(clipRef);
+    if (!resolved) {
+      return null;
+    }
+    const state = this.stateManager.createState(name, resolved.clip, {}, loop, resolved.id);
+    this.refreshStateRefs();
+    return state;
+  }
+  setStates(states) {
+    const previousActive = this.activeStateName;
+    this.stateManager.clear();
+    for (const state of states) {
+      if (!state.name.trim()) {
+        continue;
+      }
+      let createdState = null;
+      if (typeof state.clipId === "string" && state.clipId.trim().length > 0) {
+        createdState = this.addState(state.name, state.clipId, Boolean(state.loop));
+      }
+      if (!createdState) {
+        this.addState(state.name, state.clip, Boolean(state.loop));
+      }
+    }
+    if (previousActive) {
+      this.stateManager.switchState(previousActive, !this.paused);
+    }
+    this.refreshStateRefs();
+  }
+  getStateConfigs() {
+    return this.states.map((state) => ({
+      name: state.name,
+      clip: state.clip.name,
+      clipId: state.clipId,
+      loop: state.loop
+    }));
+  }
+  setActiveState(name, autoPlay = true) {
+    if (!name) {
+      const stopped = this.stateManager.stopState();
+      this.paused = true;
+      this.refreshStateRefs();
+      return stopped;
+    }
+    return this.switchState(name, autoPlay);
+  }
+  removeState(name) {
+    const removed = this.stateManager.removeState(name);
+    if (removed) {
+      this.refreshStateRefs();
+    }
+    return removed;
+  }
+  switchState(name, autoPlay = true) {
+    const state = this.stateManager.switchState(name, autoPlay);
+    if (!state) {
+      return false;
+    }
+    this.paused = !state.isPlaying;
+    this.refreshStateRefs();
+    return true;
+  }
+  playState(name) {
+    const played = this.stateManager.playState(name);
+    if (!played) {
+      return false;
+    }
+    this.paused = false;
+    this.refreshStateRefs();
+    return true;
+  }
+  pauseState(name) {
+    const paused = this.stateManager.pauseState(name);
+    if (!paused) {
+      return false;
+    }
+    this.paused = true;
+    this.refreshStateRefs();
+    return true;
+  }
+  stopState(name) {
+    const stopped = this.stateManager.stopState(name);
+    if (!stopped) {
+      return false;
+    }
+    this.paused = true;
+    this.refreshStateRefs();
+    return true;
+  }
+};
+__name(_AnimationComponent, "AnimationComponent");
+var AnimationComponent = _AnimationComponent;
+var DEFAULT_FOV = 50;
+var DEFAULT_NEAR = 0.1;
+var DEFAULT_FAR = 2e3;
+var DEFAULT_ORTHO_LEFT = -5;
+var DEFAULT_ORTHO_RIGHT = 5;
+var DEFAULT_ORTHO_TOP = 5;
+var DEFAULT_ORTHO_BOTTOM = -5;
+var DEFAULT_ZOOM = 1;
+function inferProjection(camera) {
+  if (camera instanceof THREE4__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 THREE4__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 THREE4__namespace.OrthographicCamera && Number.isFinite(camera.left)) {
+    return camera.left;
+  }
+  return DEFAULT_ORTHO_LEFT;
+}
+__name(inferOrthoLeft, "inferOrthoLeft");
+function inferOrthoRight(camera) {
+  if (camera instanceof THREE4__namespace.OrthographicCamera && Number.isFinite(camera.right)) {
+    return camera.right;
+  }
+  return DEFAULT_ORTHO_RIGHT;
+}
+__name(inferOrthoRight, "inferOrthoRight");
+function inferOrthoTop(camera) {
+  if (camera instanceof THREE4__namespace.OrthographicCamera && Number.isFinite(camera.top)) {
+    return camera.top;
+  }
+  return DEFAULT_ORTHO_TOP;
+}
+__name(inferOrthoTop, "inferOrthoTop");
+function inferOrthoBottom(camera) {
+  if (camera instanceof THREE4__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 THREE4__namespace.PerspectiveCamera();
+    this.type = payload.type ?? "3d";
+    this.isDefault = typeof payload.isDefault === "boolean" ? payload.isDefault : false;
+    this.projection = payload.projection ?? inferProjection(payload.camera);
+    this.fov = typeof payload.fov === "number" && Number.isFinite(payload.fov) ? payload.fov : inferFov(payload.camera);
+    this.near = typeof payload.near === "number" && Number.isFinite(payload.near) ? payload.near : inferNear(payload.camera);
+    this.far = typeof payload.far === "number" && Number.isFinite(payload.far) ? payload.far : inferFar(payload.camera);
+    this.left = typeof payload.left === "number" && Number.isFinite(payload.left) ? payload.left : inferOrthoLeft(payload.camera);
+    this.right = typeof payload.right === "number" && Number.isFinite(payload.right) ? payload.right : inferOrthoRight(payload.camera);
+    this.top = typeof payload.top === "number" && Number.isFinite(payload.top) ? payload.top : inferOrthoTop(payload.camera);
+    this.bottom = typeof payload.bottom === "number" && Number.isFinite(payload.bottom) ? payload.bottom : inferOrthoBottom(payload.camera);
+    this.zoom = typeof payload.zoom === "number" && Number.isFinite(payload.zoom) ? payload.zoom : inferZoom(payload.camera);
+  }
+};
+__name(_CameraComponent, "CameraComponent");
+var CameraComponent = _CameraComponent;
+
+// core/components/Audio.ts
+var DEFAULT_AUDIO_OPTIONS = {
+  autoplay: false,
+  loop: false,
+  pitch: 1,
+  volume: 1,
+  positional: false,
+  refDistance: 1,
+  distanceModel: "inverse",
+  rolloffFactor: 1
+};
+var _AudioComponent = class _AudioComponent extends Component {
+  constructor(path, options = {}) {
+    super();
+    this.path = path;
+    this.options = {
+      ...DEFAULT_AUDIO_OPTIONS,
+      ...options
+    };
+    this.object = null;
+    this.audio = null;
+    Object.defineProperty(this, "isPlaying", {
+      value: false,
+      writable: true,
+      configurable: true,
+      enumerable: false
+    });
+    Object.defineProperty(this, "isPaused", {
+      value: false,
+      writable: true,
+      configurable: true,
+      enumerable: false
+    });
+  }
+  /**
+   * Signals `AudioSystem` to start (or resume) playback.
+   * Has no direct effect in the editor — `AudioSystem` drives the actual
+   * THREE.js call in preview.
+   */
+  play() {
+    this.isPlaying = true;
+    this.isPaused = false;
+  }
+  /**
+   * Signals `AudioSystem` to pause playback, preserving the current position.
+   * Calling {@link play} afterwards resumes from where it paused.
+   * No-op if not currently playing.
+   */
+  pause() {
+    if (!this.isPlaying) return;
+    this.isPlaying = false;
+    this.isPaused = true;
+  }
+  /**
+   * Signals `AudioSystem` to stop playback and reset the playback position.
+   */
+  stop() {
+    this.isPlaying = false;
+    this.isPaused = false;
+  }
+};
+__name(_AudioComponent, "AudioComponent");
+var AudioComponent = _AudioComponent;
+
+// core/components/Environment.ts
+var DEFAULT_ENVIRONMENT_STATE = {
+  skybox: {
+    type: "none",
+    color: "#1e1e1e",
+    imageUrl: "",
+    gradient: {
+      colors: ["#464766", "#657ea6", "#0f0e1a"],
+      effect: "linear"
+    }
+  },
+  fog: {
+    type: "none",
+    color: "#1e1e1e",
+    linear: {
+      near: 1,
+      far: 100
+    },
+    exponential: {
+      density: 2e-3
+    }
+  },
+  gravity: {
+    x: 0,
+    y: -9.81,
+    z: 0
+  },
+  fixedTimeStep: 0.02
+};
+function normalizeColors(colors) {
+  if (!Array.isArray(colors)) {
+    return [...DEFAULT_ENVIRONMENT_STATE.skybox.gradient.colors];
+  }
+  const normalized = colors.filter(
+    (entry) => typeof entry === "string" && entry.length > 0
+  );
+  if (normalized.length === 0) {
+    return [...DEFAULT_ENVIRONMENT_STATE.skybox.gradient.colors];
+  }
+  return normalized;
+}
+__name(normalizeColors, "normalizeColors");
+function normalizeGradientEffect(value) {
+  if (value === "radial" || value === "linear" || value === "angular") {
+    return value;
+  }
+  return DEFAULT_ENVIRONMENT_STATE.skybox.gradient.effect;
+}
+__name(normalizeGradientEffect, "normalizeGradientEffect");
+function normalizeSkyboxType(value) {
+  if (value === "gradient" || value === "color" || value === "none") {
+    return value;
+  }
+  if (value === "image" || value === "Image") {
+    return "image";
+  }
+  return DEFAULT_ENVIRONMENT_STATE.skybox.type;
+}
+__name(normalizeSkyboxType, "normalizeSkyboxType");
+function normalizeFogType(value) {
+  if (value === "linear" || value === "exponential" || value === "none") {
+    return value;
+  }
+  return DEFAULT_ENVIRONMENT_STATE.fog.type;
+}
+__name(normalizeFogType, "normalizeFogType");
+function toFiniteNumber(value, fallback) {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    return fallback;
+  }
+  return value;
+}
+__name(toFiniteNumber, "toFiniteNumber");
+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: toFiniteNumber(
+            fog?.linear?.near,
+            DEFAULT_ENVIRONMENT_STATE.fog.linear.near
+          ),
+          far: toFiniteNumber(
+            fog?.linear?.far,
+            DEFAULT_ENVIRONMENT_STATE.fog.linear.far
+          )
+        },
+        exponential: {
+          density: toFiniteNumber(
+            fog?.exponential?.density,
+            DEFAULT_ENVIRONMENT_STATE.fog.exponential.density
+          )
+        }
+      },
+      gravity: {
+        x: toFiniteNumber(gravity?.x, DEFAULT_ENVIRONMENT_STATE.gravity.x),
+        y: toFiniteNumber(gravity?.y, DEFAULT_ENVIRONMENT_STATE.gravity.y),
+        z: toFiniteNumber(gravity?.z, DEFAULT_ENVIRONMENT_STATE.gravity.z)
+      },
+      fixedTimeStep: toFiniteNumber(
+        values?.fixedTimeStep,
+        DEFAULT_ENVIRONMENT_STATE.fixedTimeStep
+      )
+    };
+  }
+};
+__name(_Environment, "Environment");
+var Environment = _Environment;
+
+// core/components/Postprocessing.ts
+var DEFAULT_POSTPROCESSING_STATE = {
+  postEnabled: false,
+  dof: {
+    enabled: false,
+    focusDistance: 0.015,
+    focalLength: 0.018,
+    bokehScale: 3
+  },
+  bloom: {
+    enabled: false,
+    intensity: 1.2,
+    threshold: 0.2,
+    radius: 0.7
+  },
+  vignette: {
+    enabled: false,
+    offset: 0.05,
+    darkness: 1.2
+  },
+  chromAberration: {
+    enabled: false,
+    offsetX: 3e-3,
+    offsetY: 3e-3
+  },
+  noise: {
+    enabled: false,
+    opacity: 0.12
+  },
+  pixelation: {
+    enabled: false,
+    granularity: 6
+  },
+  toneMapping: {
+    enabled: false,
+    exposure: 1.3
+  },
+  hueSaturation: {
+    enabled: false,
+    hue: 0.05,
+    saturation: 0.2
+  },
+  sepia: {
+    enabled: false,
+    intensity: 0.5
+  },
+  smaa: {
+    enabled: false
+  },
+  ssao: {
+    enabled: false,
+    intensity: 1.5,
+    radius: 0.25
+  },
+  dotScreen: {
+    enabled: false,
+    dotScreenScale: 1.2,
+    dotScreenAngle: 1.57,
+    scale: 1.2,
+    angle: 1.57,
+    blendFunction: void 0,
+    opacity: void 0
+  },
+  glitch: {
+    enabled: false,
+    blendFunction: void 0,
+    chromaticAberrationOffset: void 0,
+    delay: void 0,
+    duration: void 0,
+    strength: void 0,
+    dtSize: void 0,
+    columns: void 0,
+    ratio: void 0,
+    mode: void 0,
+    active: void 0
+  }
+};
+function asRecord(value) {
+  if (!value || typeof value !== "object") {
+    return null;
+  }
+  return value;
+}
+__name(asRecord, "asRecord");
+function toFiniteNumber2(value, fallback) {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    return fallback;
+  }
+  return value;
+}
+__name(toFiniteNumber2, "toFiniteNumber");
+function toBoolean(value, fallback) {
+  if (typeof value !== "boolean") {
+    return fallback;
+  }
+  return value;
+}
+__name(toBoolean, "toBoolean");
+function normalizeNumberTuple(value) {
+  if (!Array.isArray(value) || value.length !== 2) {
+    return void 0;
+  }
+  if (typeof value[0] !== "number" || !Number.isFinite(value[0]) || typeof value[1] !== "number" || !Number.isFinite(value[1])) {
+    return void 0;
+  }
+  return [value[0], value[1]];
+}
+__name(normalizeNumberTuple, "normalizeNumberTuple");
+function normalizePostprocessing(value) {
+  const postprocessing = asRecord(value);
+  const defaults = DEFAULT_POSTPROCESSING_STATE;
+  const dof = asRecord(postprocessing?.dof);
+  const bloom = asRecord(postprocessing?.bloom);
+  const vignette = asRecord(postprocessing?.vignette);
+  const chromAberration = asRecord(postprocessing?.chromAberration);
+  const noise = asRecord(postprocessing?.noise);
+  const pixelation = asRecord(postprocessing?.pixelation);
+  const toneMapping = asRecord(postprocessing?.toneMapping);
+  const hueSaturation = asRecord(postprocessing?.hueSaturation);
+  const sepia = asRecord(postprocessing?.sepia);
+  const smaa = asRecord(postprocessing?.smaa);
+  const ssao = asRecord(postprocessing?.ssao);
+  const dotScreen = asRecord(postprocessing?.dotScreen);
+  const glitch = asRecord(postprocessing?.glitch);
+  const glitchChromaticAberrationOffset = asRecord(
+    glitch?.chromaticAberrationOffset
+  );
+  const glitchStrength = asRecord(glitch?.strength);
+  const dotScreenScale = toFiniteNumber2(
+    dotScreen?.dotScreenScale,
+    defaults.dotScreen.dotScreenScale
+  );
+  const dotScreenAngle = toFiniteNumber2(
+    dotScreen?.dotScreenAngle,
+    defaults.dotScreen.dotScreenAngle
+  );
+  const normalizedGlitchStrength = typeof glitch?.strength === "number" && Number.isFinite(glitch.strength) ? glitch.strength : glitchStrength && typeof glitchStrength.x === "number" && Number.isFinite(glitchStrength.x) && typeof glitchStrength.y === "number" && Number.isFinite(glitchStrength.y) ? { x: glitchStrength.x, y: glitchStrength.y } : void 0;
+  const normalizedGlitchChromaticAberrationOffset = normalizeNumberTuple(glitch?.chromaticAberrationOffset) ?? (glitchChromaticAberrationOffset && typeof glitchChromaticAberrationOffset.x === "number" && Number.isFinite(glitchChromaticAberrationOffset.x) && typeof glitchChromaticAberrationOffset.y === "number" && Number.isFinite(glitchChromaticAberrationOffset.y) ? {
+    x: glitchChromaticAberrationOffset.x,
+    y: glitchChromaticAberrationOffset.y
+  } : void 0);
+  return {
+    postEnabled: toBoolean(postprocessing?.postEnabled, defaults.postEnabled),
+    dof: {
+      enabled: toBoolean(dof?.enabled, defaults.dof.enabled),
+      focusDistance: toFiniteNumber2(dof?.focusDistance, defaults.dof.focusDistance),
+      focalLength: toFiniteNumber2(dof?.focalLength, defaults.dof.focalLength),
+      bokehScale: toFiniteNumber2(dof?.bokehScale, defaults.dof.bokehScale)
+    },
+    bloom: {
+      enabled: toBoolean(bloom?.enabled, defaults.bloom.enabled),
+      intensity: toFiniteNumber2(bloom?.intensity, defaults.bloom.intensity),
+      threshold: toFiniteNumber2(bloom?.threshold, defaults.bloom.threshold),
+      radius: toFiniteNumber2(bloom?.radius, defaults.bloom.radius)
+    },
+    vignette: {
+      enabled: toBoolean(vignette?.enabled, defaults.vignette.enabled),
+      offset: toFiniteNumber2(vignette?.offset, defaults.vignette.offset),
+      darkness: toFiniteNumber2(vignette?.darkness, defaults.vignette.darkness)
+    },
+    chromAberration: {
+      enabled: toBoolean(chromAberration?.enabled, defaults.chromAberration.enabled),
+      offsetX: toFiniteNumber2(chromAberration?.offsetX, defaults.chromAberration.offsetX),
+      offsetY: toFiniteNumber2(chromAberration?.offsetY, defaults.chromAberration.offsetY)
+    },
+    noise: {
+      enabled: toBoolean(noise?.enabled, defaults.noise.enabled),
+      opacity: toFiniteNumber2(noise?.opacity, defaults.noise.opacity)
+    },
+    pixelation: {
+      enabled: toBoolean(pixelation?.enabled, defaults.pixelation.enabled),
+      granularity: toFiniteNumber2(pixelation?.granularity, defaults.pixelation.granularity)
+    },
+    toneMapping: {
+      enabled: toBoolean(toneMapping?.enabled, defaults.toneMapping.enabled),
+      exposure: toFiniteNumber2(toneMapping?.exposure, defaults.toneMapping.exposure)
+    },
+    hueSaturation: {
+      enabled: toBoolean(hueSaturation?.enabled, defaults.hueSaturation.enabled),
+      hue: toFiniteNumber2(hueSaturation?.hue, defaults.hueSaturation.hue),
+      saturation: toFiniteNumber2(
+        hueSaturation?.saturation,
+        defaults.hueSaturation.saturation
+      )
+    },
+    sepia: {
+      enabled: toBoolean(sepia?.enabled, defaults.sepia.enabled),
+      intensity: toFiniteNumber2(sepia?.intensity, defaults.sepia.intensity)
+    },
+    smaa: {
+      enabled: toBoolean(smaa?.enabled, defaults.smaa.enabled)
+    },
+    ssao: {
+      enabled: toBoolean(ssao?.enabled, defaults.ssao.enabled),
+      intensity: toFiniteNumber2(ssao?.intensity, defaults.ssao.intensity),
+      radius: toFiniteNumber2(ssao?.radius, defaults.ssao.radius)
+    },
+    dotScreen: {
+      enabled: toBoolean(dotScreen?.enabled, defaults.dotScreen.enabled),
+      dotScreenScale,
+      dotScreenAngle,
+      scale: toFiniteNumber2(dotScreen?.scale, dotScreenScale),
+      angle: toFiniteNumber2(dotScreen?.angle, dotScreenAngle),
+      blendFunction: typeof dotScreen?.blendFunction === "number" && Number.isFinite(dotScreen.blendFunction) ? dotScreen.blendFunction : defaults.dotScreen.blendFunction,
+      opacity: typeof dotScreen?.opacity === "number" && Number.isFinite(dotScreen.opacity) ? dotScreen.opacity : defaults.dotScreen.opacity
+    },
+    glitch: {
+      enabled: toBoolean(glitch?.enabled, defaults.glitch.enabled),
+      blendFunction: typeof glitch?.blendFunction === "number" && Number.isFinite(glitch.blendFunction) ? glitch.blendFunction : defaults.glitch.blendFunction,
+      chromaticAberrationOffset: normalizedGlitchChromaticAberrationOffset,
+      delay: normalizeNumberTuple(glitch?.delay) ?? defaults.glitch.delay,
+      duration: normalizeNumberTuple(glitch?.duration) ?? defaults.glitch.duration,
+      strength: normalizedGlitchStrength,
+      dtSize: typeof glitch?.dtSize === "number" && Number.isFinite(glitch.dtSize) ? glitch.dtSize : defaults.glitch.dtSize,
+      columns: typeof glitch?.columns === "number" && Number.isFinite(glitch.columns) ? glitch.columns : defaults.glitch.columns,
+      ratio: typeof glitch?.ratio === "number" && Number.isFinite(glitch.ratio) ? glitch.ratio : defaults.glitch.ratio,
+      mode: typeof glitch?.mode === "string" ? glitch.mode : defaults.glitch.mode,
+      active: toBoolean(glitch?.active, defaults.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/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,
+  lockTranslationX: false,
+  lockTranslationY: false,
+  lockTranslationZ: false,
+  lockRotations: false,
+  lockRotationX: false,
+  lockRotationY: false,
+  lockRotationZ: 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
+};
+var DEFAULT_PHYSICS_STATE = {
+  rigidbody: DEFAULT_RIGIDBODY_STATE,
+  collider: DEFAULT_COLLIDER_STATE
+};
+function asRecord2(value) {
+  if (!value || typeof value !== "object") {
+    return null;
+  }
+  return value;
+}
+__name(asRecord2, "asRecord");
+function toFiniteNumber3(value, fallback) {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    return fallback;
+  }
+  return value;
+}
+__name(toFiniteNumber3, "toFiniteNumber");
+function toBoolean2(value, fallback) {
+  if (typeof value !== "boolean") {
+    return fallback;
+  }
+  return value;
+}
+__name(toBoolean2, "toBoolean");
+function toRigidbodyType(value, fallback) {
+  if (value === "dynamic" || value === "fixed" || value === "kinematicPosition" || value === "kinematicVelocity") {
+    return value;
+  }
+  return fallback;
+}
+__name(toRigidbodyType, "toRigidbodyType");
+function toColliderShape(value, fallback) {
+  if (value === "cuboid" || value === "ball" || value === "capsule" || value === "cylinder" || value === "trimesh") {
+    return value;
+  }
+  return fallback;
+}
+__name(toColliderShape, "toColliderShape");
+function normalizeRigidbodyState(value) {
+  const source = asRecord2(value);
+  const defaults = DEFAULT_RIGIDBODY_STATE;
+  const legacyLockTranslations = toBoolean2(
+    source?.lockTranslations,
+    defaults.lockTranslations
+  );
+  const legacyLockRotations = toBoolean2(
+    source?.lockRotations,
+    defaults.lockRotations
+  );
+  const lockTranslationX = toBoolean2(
+    source?.lockTranslationX,
+    legacyLockTranslations
+  );
+  const lockTranslationY = toBoolean2(
+    source?.lockTranslationY,
+    legacyLockTranslations
+  );
+  const lockTranslationZ = toBoolean2(
+    source?.lockTranslationZ,
+    legacyLockTranslations
+  );
+  const lockRotationX = toBoolean2(source?.lockRotationX, legacyLockRotations);
+  const lockRotationY = toBoolean2(source?.lockRotationY, legacyLockRotations);
+  const lockRotationZ = toBoolean2(source?.lockRotationZ, legacyLockRotations);
+  return {
+    enabled: toBoolean2(source?.enabled, defaults.enabled),
+    type: toRigidbodyType(source?.type, defaults.type),
+    mass: Math.max(1e-4, toFiniteNumber3(source?.mass, defaults.mass)),
+    linearDamping: Math.max(
+      0,
+      toFiniteNumber3(source?.linearDamping, defaults.linearDamping)
+    ),
+    angularDamping: Math.max(
+      0,
+      toFiniteNumber3(source?.angularDamping, defaults.angularDamping)
+    ),
+    gravityScale: toFiniteNumber3(source?.gravityScale, defaults.gravityScale),
+    canSleep: toBoolean2(source?.canSleep, defaults.canSleep),
+    ccdEnabled: toBoolean2(source?.ccdEnabled, defaults.ccdEnabled),
+    lockTranslations: legacyLockTranslations,
+    lockTranslationX,
+    lockTranslationY,
+    lockTranslationZ,
+    lockRotations: legacyLockRotations,
+    lockRotationX,
+    lockRotationY,
+    lockRotationZ
+  };
+}
+__name(normalizeRigidbodyState, "normalizeRigidbodyState");
+function normalizeColliderState(value) {
+  const source = asRecord2(value);
+  const defaults = DEFAULT_COLLIDER_STATE;
+  const offsetPosition = asRecord2(source?.offsetPosition);
+  const offsetRotation = asRecord2(source?.offsetRotation);
+  const size = asRecord2(source?.size);
+  return {
+    enabled: toBoolean2(source?.enabled, defaults.enabled),
+    shape: toColliderShape(source?.shape, defaults.shape),
+    offsetPosition: {
+      x: toFiniteNumber3(offsetPosition?.x, defaults.offsetPosition.x),
+      y: toFiniteNumber3(offsetPosition?.y, defaults.offsetPosition.y),
+      z: toFiniteNumber3(offsetPosition?.z, defaults.offsetPosition.z)
+    },
+    offsetRotation: {
+      x: toFiniteNumber3(offsetRotation?.x, defaults.offsetRotation.x),
+      y: toFiniteNumber3(offsetRotation?.y, defaults.offsetRotation.y),
+      z: toFiniteNumber3(offsetRotation?.z, defaults.offsetRotation.z)
+    },
+    size: {
+      x: Math.max(1e-4, toFiniteNumber3(size?.x, defaults.size.x)),
+      y: Math.max(1e-4, toFiniteNumber3(size?.y, defaults.size.y)),
+      z: Math.max(1e-4, toFiniteNumber3(size?.z, defaults.size.z))
+    },
+    radius: Math.max(1e-4, toFiniteNumber3(source?.radius, defaults.radius)),
+    height: Math.max(1e-4, toFiniteNumber3(source?.height, defaults.height)),
+    restitution: Math.max(0, toFiniteNumber3(source?.restitution, defaults.restitution)),
+    friction: Math.max(0, toFiniteNumber3(source?.friction, defaults.friction)),
+    isSensor: toBoolean2(source?.isSensor, defaults.isSensor)
+  };
+}
+__name(normalizeColliderState, "normalizeColliderState");
+function normalizePhysicsState(value) {
+  const source = asRecord2(value);
+  return {
+    rigidbody: normalizeRigidbodyState(
+      source?.rigidbody ?? void 0
+    ),
+    collider: normalizeColliderState(
+      source?.collider ?? void 0
+    )
+  };
+}
+__name(normalizePhysicsState, "normalizePhysicsState");
+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/components/EntityType.ts
+var _EntityType = class _EntityType extends Component {
+  constructor(value) {
+    super();
+    this.value = value;
+  }
+};
+__name(_EntityType, "EntityType");
+var EntityType = _EntityType;
+
+// core/components/Image.ts
+var _ImageComponent = class _ImageComponent extends Component {
+  constructor(path, width = 1, height = 1) {
+    super();
+    this.path = path;
+    this.width = width;
+    this.height = height;
+    this.texture = null;
+    this.object = null;
+  }
+};
+__name(_ImageComponent, "ImageComponent");
+var ImageComponent = _ImageComponent;
+
+// core/components/ImageTarget.ts
+var _ImageTarget = class _ImageTarget extends Component {
+  constructor(options, texture, object) {
+    super();
+    this.targets = options?.targets ?? [];
+    this.compiledTargetUrl = options?.compiledTargetUrl;
+    this.compiledTargetDir = options?.compiledTargetDir;
+    this.texture = texture ?? null;
+    this.object = object ?? null;
+  }
+};
+__name(_ImageTarget, "ImageTarget");
+var ImageTarget = _ImageTarget;
+
+// 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;
+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 THREE4__namespace.PointLight) {
+    base.distance = light.distance;
+    base.decay = light.decay;
+  } else if (light instanceof THREE4__namespace.SpotLight) {
+    base.distance = light.distance;
+    base.decay = light.decay;
+    base.angle = light.angle;
+    base.penumbra = light.penumbra;
+  } else if (light instanceof THREE4__namespace.RectAreaLight) {
+    base.width = light.width;
+    base.height = light.height;
+  }
+  return base;
+}
+__name(createValueState, "createValueState");
+var _LightComponent = class _LightComponent extends Component {
+  constructor(light) {
+    super();
+    this.light = light;
+    this.type = light.type;
+    this.values = createValueState(light);
+  }
+  setValues(patch) {
+    this.values = {
+      ...this.values,
+      ...patch
+    };
+  }
+};
+__name(_LightComponent, "LightComponent");
+var LightComponent = _LightComponent;
+function toHexColor2(value, fallback) {
+  if (value && typeof value === "object" && typeof value.getHexString === "function") {
+    try {
+      return `#${value.getHexString()}`;
+    } catch {
+      return fallback;
+    }
+  }
+  return fallback;
+}
+__name(toHexColor2, "toHexColor");
+function getMaterialType(material) {
+  if (material instanceof THREE4__namespace.MeshPhysicalMaterial) {
+    return "physical";
+  }
+  if (material instanceof THREE4__namespace.MeshPhongMaterial) {
+    return "phong";
+  }
+  if (material instanceof THREE4__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 : THREE4__namespace.FrontSide,
+    blending: typeof materialRecord.blending === "number" ? materialRecord.blending : THREE4__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 === THREE4__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: THREE4__namespace.FrontSide,
+    blending: THREE4__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/components/Mesh.ts
+var _MeshComponent = class _MeshComponent extends Component {
+  constructor(mesh) {
+    super();
+    this.mesh = mesh;
+  }
+};
+__name(_MeshComponent, "MeshComponent");
+var MeshComponent = _MeshComponent;
+var DEFAULT_MESH_GEOMETRY_PARAMETERS = {
+  capsule: { radius: 0.5, height: 1 },
+  cube: { width: 1, height: 1, depth: 1 },
+  cylinder: { radius: 0.5, height: 1 },
+  model: {},
+  plane: { width: 100, height: 100 },
+  sphere: { radius: 0.5 }
+};
+var GEOMETRY_TYPE_BY_KIND = {
+  capsule: "CapsuleGeometry",
+  cube: "BoxGeometry",
+  cylinder: "CylinderGeometry",
+  model: "Model",
+  plane: "PlaneGeometry",
+  sphere: "SphereGeometry"
+};
+var _MeshGeometryComponent = class _MeshGeometryComponent extends Component {
+  constructor(kind, object, parameters, options) {
+    super();
+    this.kind = kind;
+    this.geometryType = GEOMETRY_TYPE_BY_KIND[kind];
+    this.object = object;
+    this.modelName = options?.modelName ?? "";
+    this.castShadow = options?.castShadow ?? false;
+    this.receiveShadow = options?.receiveShadow ?? false;
+    switch (kind) {
+      case "cube":
+        this.parameters = {
+          ...DEFAULT_MESH_GEOMETRY_PARAMETERS.cube,
+          ...parameters
+        };
+        break;
+      case "plane":
+        this.parameters = {
+          ...DEFAULT_MESH_GEOMETRY_PARAMETERS.plane,
+          ...parameters
+        };
+        break;
+      case "sphere":
+        this.parameters = {
+          ...DEFAULT_MESH_GEOMETRY_PARAMETERS.sphere,
+          ...parameters
+        };
+        break;
+      case "cylinder":
+        this.parameters = {
+          ...DEFAULT_MESH_GEOMETRY_PARAMETERS.cylinder,
+          ...parameters
+        };
+        break;
+      case "capsule":
+        this.parameters = {
+          ...DEFAULT_MESH_GEOMETRY_PARAMETERS.capsule,
+          ...parameters
+        };
+        break;
+      case "model":
+        this.parameters = {};
+        break;
+    }
+  }
+};
+__name(_MeshGeometryComponent, "MeshGeometryComponent");
+var MeshGeometryComponent = _MeshGeometryComponent;
+
+// core/components/Model.ts
+var _ModelComponent = class _ModelComponent extends Component {
+  constructor(path) {
+    super();
+    this.path = path;
+    this.object = null;
+  }
+};
+__name(_ModelComponent, "ModelComponent");
+var ModelComponent = _ModelComponent;
+
+// core/components/Name.ts
+var _Name = class _Name extends Component {
+  constructor(value) {
+    super();
+    this.value = value;
+  }
+};
+__name(_Name, "Name");
+var Name = _Name;
+
+// core/components/Object3DRef.ts
+var _Object3DRef = class _Object3DRef extends Component {
+  constructor(object, visibility) {
+    super();
+    this.object = object;
+    this.visibility = typeof visibility === "boolean" ? visibility : Boolean(object.visible);
+  }
+};
+__name(_Object3DRef, "Object3DRef");
+var Object3DRef = _Object3DRef;
+
+// core/components/ParentId.ts
+var _ParentId = class _ParentId extends Component {
+  constructor(value = null) {
+    super();
+    this.value = value;
+  }
+};
+__name(_ParentId, "ParentId");
+var ParentId = _ParentId;
+
+// core/components/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/components/Selectable.ts
+var _Selectable = class _Selectable extends Component {
+  constructor(enabled = true) {
+    super();
+    this.enabled = enabled;
+  }
+};
+__name(_Selectable, "Selectable");
+var Selectable = _Selectable;
+
+// core/components/Sprite.ts
+var _SpriteComponent = class _SpriteComponent extends Component {
+  constructor(path, width = 1, height = 1) {
+    super();
+    this.path = path;
+    this.width = width;
+    this.height = height;
+    this.texture = null;
+    this.object = null;
+  }
+};
+__name(_SpriteComponent, "SpriteComponent");
+var SpriteComponent = _SpriteComponent;
+
+// 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;
+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 THREE4.Vector3()) {
+    return target.set(this.position.x, this.position.y, this.position.z);
+  }
+  toRotationEuler(target = new THREE4.Euler(), order = "XYZ") {
+    return target.set(this.rotation.x, this.rotation.y, this.rotation.z, order);
+  }
+  toRotationQuaternion(target = new THREE4.Quaternion(), order = "XYZ") {
+    const euler = new THREE4.Euler(
+      this.rotation.x,
+      this.rotation.y,
+      this.rotation.z,
+      order
+    );
+    return target.setFromEuler(euler);
+  }
+  toScaleVector3(target = new THREE4.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 THREE4.Quaternion) {
+      const euler = new THREE4.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/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;
+
+exports.AnimationComponent = AnimationComponent;
+exports.AudioComponent = AudioComponent;
+exports.CameraComponent = CameraComponent;
+exports.DEFAULT_COLLIDER_STATE = DEFAULT_COLLIDER_STATE;
+exports.DEFAULT_ENVIRONMENT_STATE = DEFAULT_ENVIRONMENT_STATE;
+exports.DEFAULT_MESH_GEOMETRY_PARAMETERS = DEFAULT_MESH_GEOMETRY_PARAMETERS;
+exports.DEFAULT_PHYSICS_STATE = DEFAULT_PHYSICS_STATE;
+exports.DEFAULT_POSTPROCESSING_STATE = DEFAULT_POSTPROCESSING_STATE;
+exports.DEFAULT_RIGIDBODY_STATE = DEFAULT_RIGIDBODY_STATE;
+exports.EntityType = EntityType;
+exports.Environment = Environment;
+exports.ImageComponent = ImageComponent;
+exports.ImageTarget = ImageTarget;
+exports.ImageTargetAnchor = ImageTargetAnchor;
+exports.LightComponent = LightComponent;
+exports.MaterialComponent = MaterialComponent;
+exports.MeshComponent = MeshComponent;
+exports.MeshGeometryComponent = MeshGeometryComponent;
+exports.ModelComponent = ModelComponent;
+exports.Name = Name;
+exports.Object3DRef = Object3DRef;
+exports.ParentId = ParentId;
+exports.PhysicsComponent = PhysicsComponent;
+exports.Postprocessing = Postprocessing;
+exports.ScriptComponent = ScriptComponent;
+exports.Selectable = Selectable;
+exports.SelectionTransformState = SelectionTransformState;
+exports.SpriteComponent = SpriteComponent;
+exports.TransformComponent = TransformComponent;
+exports.VideoComponent = VideoComponent;
+exports.normalizePhysicsState = normalizePhysicsState;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map