@relu-interactives/spatial-ecs 0.2.2

package/dist/chunk-P2YDX5DB.js

@@ -0,0 +1,3304 @@
+import { resolveDracoDecoderPath, applyTransform } from './chunk-AYEF3X2P.js';
+import { AnimationComponent, ModelComponent, CameraComponent, Object3DRef, Environment, Postprocessing, TransformComponent, PhysicsComponent, LightComponent, MaterialComponent, DEFAULT_MESH_GEOMETRY_PARAMETERS, MeshGeometryComponent, ParentId, ScriptComponent, AudioComponent, VideoComponent } from './chunk-MAWBTMCG.js';
+import { __name } from './chunk-OY7ZODZP.js';
+import * as THREE7 from 'three';
+import { DRACOLoader } from 'three/examples/jsm/loaders/DRACOLoader.js';
+import { FBXLoader } from 'three/examples/jsm/loaders/FBXLoader.js';
+import { GLTFLoader } from 'three/examples/jsm/loaders/GLTFLoader.js';
+import { EffectComposer } from 'three/examples/jsm/postprocessing/EffectComposer.js';
+import { RenderPass } from 'three/examples/jsm/postprocessing/RenderPass.js';
+import { UnrealBloomPass } from 'three/examples/jsm/postprocessing/UnrealBloomPass.js';
+import { DotScreenPass } from 'three/examples/jsm/postprocessing/DotScreenPass.js';
+import { GlitchPass } from 'three/examples/jsm/postprocessing/GlitchPass.js';
+import { FilmPass } from 'three/examples/jsm/postprocessing/FilmPass.js';
+import { BokehPass } from 'three/examples/jsm/postprocessing/BokehPass.js';
+import { SSAOPass } from 'three/examples/jsm/postprocessing/SSAOPass.js';
+import { ShaderPass } from 'three/examples/jsm/postprocessing/ShaderPass.js';
+import { OutputPass } from 'three/examples/jsm/postprocessing/OutputPass.js';
+import { HueSaturationShader } from 'three/examples/jsm/shaders/HueSaturationShader.js';
+import { SepiaShader } from 'three/examples/jsm/shaders/SepiaShader.js';
+import { VignetteShader } from 'three/examples/jsm/shaders/VignetteShader.js';
+
+function createClipSourceLoader() {
+  const loader = new GLTFLoader();
+  try {
+    const dracoLoader = new DRACOLoader();
+    dracoLoader.setDecoderPath(resolveDracoDecoderPath());
+    loader.setDRACOLoader(dracoLoader);
+  } catch (error) {
+    console.warn("DRACOLoader could not be configured for clip source loading.", error);
+  }
+  return loader;
+}
+__name(createClipSourceLoader, "createClipSourceLoader");
+function normalizeDeltaTime(deltaTime) {
+  return Number.isFinite(deltaTime) ? Math.max(0, deltaTime) : 0;
+}
+__name(normalizeDeltaTime, "normalizeDeltaTime");
+function sanitizeTimeScale(timeScale) {
+  if (!Number.isFinite(timeScale) || Math.abs(timeScale) < 1e-4) {
+    return 1;
+  }
+  return Math.abs(timeScale);
+}
+__name(sanitizeTimeScale, "sanitizeTimeScale");
+function sanitizeCrossFadeDuration(duration) {
+  if (!Number.isFinite(duration) || duration < 0) {
+    return 0;
+  }
+  return duration;
+}
+__name(sanitizeCrossFadeDuration, "sanitizeCrossFadeDuration");
+function buildClipSignature(entries) {
+  return entries.map((entry) => entry.id).sort((a, b) => a.localeCompare(b)).join("|");
+}
+__name(buildClipSignature, "buildClipSignature");
+function readRuntimeClipEntries(animation) {
+  if (Array.isArray(animation.clipCatalog) && animation.clipCatalog.length > 0) {
+    return animation.clipCatalog.map((entry) => ({
+      id: entry.id,
+      name: entry.name,
+      clip: entry.clip
+    }));
+  }
+  if (!Array.isArray(animation.clips)) {
+    return [];
+  }
+  return animation.clips.map((clip, index) => {
+    const name = typeof clip?.name === "string" ? clip.name : "";
+    if (!name) {
+      return null;
+    }
+    return {
+      id: `legacy:${index}:${name}`,
+      name,
+      clip
+    };
+  }).filter((entry) => entry !== null);
+}
+__name(readRuntimeClipEntries, "readRuntimeClipEntries");
+function normalizeClipSources(value) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const sources = [];
+  for (const entry of value) {
+    if (typeof entry !== "string") {
+      continue;
+    }
+    const trimmed = entry.trim();
+    if (!trimmed || seen.has(trimmed)) {
+      continue;
+    }
+    seen.add(trimmed);
+    sources.push(trimmed);
+  }
+  return sources;
+}
+__name(normalizeClipSources, "normalizeClipSources");
+function extractFileExtension(url) {
+  const clean = url.split("?")[0]?.split("#")[0] ?? "";
+  const ext = clean.split(".").pop();
+  return typeof ext === "string" ? ext.toLowerCase() : "";
+}
+__name(extractFileExtension, "extractFileExtension");
+function createActions(mixer, entries) {
+  const actions = /* @__PURE__ */ new Map();
+  const clipNameToIds = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    if (!entry.name) {
+      continue;
+    }
+    actions.set(entry.id, mixer.clipAction(entry.clip));
+    const ids = clipNameToIds.get(entry.name) ?? [];
+    ids.push(entry.id);
+    clipNameToIds.set(entry.name, ids);
+  }
+  return { actions, clipNameToIds };
+}
+__name(createActions, "createActions");
+function stopAllActions(runtime) {
+  runtime.actions.forEach((action) => {
+    action.stop();
+  });
+  runtime.mixer.stopAllAction();
+  runtime.activeClipId = null;
+}
+__name(stopAllActions, "stopAllActions");
+function transitionToClip(runtime, nextClipId, crossFadeDuration) {
+  if (runtime.activeClipId === nextClipId) {
+    return;
+  }
+  const previousAction = runtime.activeClipId ? runtime.actions.get(runtime.activeClipId) : void 0;
+  const nextAction = nextClipId ? runtime.actions.get(nextClipId) : void 0;
+  if (!nextAction) {
+    if (previousAction) {
+      previousAction.stop();
+    }
+    runtime.activeClipId = null;
+    return;
+  }
+  if (!previousAction || previousAction === nextAction) {
+    nextAction.reset();
+    nextAction.play();
+    runtime.activeClipId = nextClipId;
+    return;
+  }
+  if (crossFadeDuration > 0) {
+    nextAction.reset();
+    nextAction.play();
+    previousAction.crossFadeTo(nextAction, crossFadeDuration, true);
+  } else {
+    previousAction.stop();
+    nextAction.reset();
+    nextAction.play();
+  }
+  runtime.activeClipId = nextClipId;
+}
+__name(transitionToClip, "transitionToClip");
+function applyActionState(action, component, paused, shouldLoop) {
+  const loopMode = shouldLoop ? THREE7.LoopRepeat : THREE7.LoopOnce;
+  const repetitions = shouldLoop ? Infinity : 1;
+  action.setLoop(loopMode, repetitions);
+  action.clampWhenFinished = !shouldLoop;
+  action.paused = paused;
+  const direction = component.reverse ? -1 : 1;
+  action.setEffectiveTimeScale(sanitizeTimeScale(component.timeScale) * direction);
+}
+__name(applyActionState, "applyActionState");
+function applyPendingHydratedOptions(component, runtime) {
+  const pending = component.__pendingHydratedOptions;
+  if (!pending) {
+    return;
+  }
+  if (Array.isArray(pending.externalClipSources)) {
+    component.setExternalClipSources(pending.externalClipSources);
+  }
+  if (!Array.isArray(component.clips) || component.clips.length === 0) {
+    return;
+  }
+  if (runtime && runtime.pendingSources.size > 0) {
+    return;
+  }
+  const states = Array.isArray(pending.states) ? pending.states : [];
+  if (states.length > 0) {
+    component.setStates(states);
+  }
+  if (typeof pending.reverse === "boolean") {
+    component.reverse = pending.reverse;
+  }
+  if (typeof pending.timeScale === "number" && Number.isFinite(pending.timeScale)) {
+    component.timeScale = pending.timeScale;
+  }
+  if (typeof pending.crossFadeDuration === "number" && Number.isFinite(pending.crossFadeDuration)) {
+    component.crossFadeDuration = Math.max(0, pending.crossFadeDuration);
+  }
+  if (typeof pending.activeState === "string" && pending.activeState.length > 0) {
+    component.setActiveState(pending.activeState, !pending.paused);
+  }
+  if (typeof pending.paused === "boolean") {
+    if (pending.paused) {
+      component.pauseState(pending.activeState ?? void 0);
+    } else {
+      component.playState(pending.activeState ?? void 0);
+    }
+  }
+  delete component.__pendingHydratedOptions;
+}
+__name(applyPendingHydratedOptions, "applyPendingHydratedOptions");
+var _AnimationSystem = class _AnimationSystem {
+  constructor() {
+    this.runtimeByEntity = /* @__PURE__ */ new Map();
+    this.gltfLoader = createClipSourceLoader();
+    this.fbxLoader = new FBXLoader();
+  }
+  async loadClipsFromSource(sourceUrl) {
+    const ext = extractFileExtension(sourceUrl);
+    if (ext === "fbx") {
+      return new Promise((resolve, reject) => {
+        this.fbxLoader.load(
+          sourceUrl,
+          (object) => {
+            const clips = Array.isArray(object.animations) ? object.animations : [];
+            resolve(clips);
+          },
+          void 0,
+          reject
+        );
+      });
+    }
+    if (ext === "glb" || ext === "gltf") {
+      return new Promise((resolve, reject) => {
+        this.gltfLoader.load(
+          sourceUrl,
+          (gltf) => {
+            const clips = Array.isArray(gltf.animations) ? gltf.animations : [];
+            resolve(clips);
+          },
+          void 0,
+          reject
+        );
+      });
+    }
+    return [];
+  }
+  refreshExternalClipSources(world, entityId, animation, runtime) {
+    const normalizedSources = normalizeClipSources(animation.externalClipSources);
+    const sourceSignature = normalizedSources.join("|");
+    if (runtime.sourceSignature !== sourceSignature) {
+      runtime.sourceSignature = sourceSignature;
+      runtime.sourceToken += 1;
+      runtime.pendingSources.clear();
+      runtime.importedSourceClips.clear();
+      animation.setImportedClips([]);
+    }
+    const sourceSet = new Set(normalizedSources);
+    for (const loadedSource of runtime.importedSourceClips.keys()) {
+      if (!sourceSet.has(loadedSource)) {
+        runtime.importedSourceClips.delete(loadedSource);
+      }
+    }
+    [...runtime.importedSourceClips.values()].flat();
+    animation.setImportedClips(
+      normalizedSources.flatMap((sourceUrl) => {
+        const clipsForSource = runtime.importedSourceClips.get(sourceUrl) ?? [];
+        return clipsForSource.map((clip) => ({ clip, sourceUrl }));
+      })
+    );
+    for (const sourceUrl of normalizedSources) {
+      if (runtime.importedSourceClips.has(sourceUrl) || runtime.pendingSources.has(sourceUrl)) {
+        continue;
+      }
+      runtime.pendingSources.add(sourceUrl);
+      const sourceToken = runtime.sourceToken;
+      void this.loadClipsFromSource(sourceUrl).then((clips) => {
+        const currentRuntime = this.runtimeByEntity.get(entityId);
+        if (!currentRuntime || currentRuntime.sourceToken !== sourceToken) {
+          return;
+        }
+        currentRuntime.pendingSources.delete(sourceUrl);
+        currentRuntime.importedSourceClips.set(sourceUrl, clips);
+        const currentAnimation = world.getComponent(entityId, AnimationComponent);
+        if (!currentAnimation) {
+          return;
+        }
+        currentAnimation.setImportedClips(
+          normalizedSources.flatMap((url) => {
+            const clipsForSource = currentRuntime.importedSourceClips.get(url) ?? [];
+            return clipsForSource.map((clip) => ({ clip, sourceUrl: url }));
+          })
+        );
+      }).catch((error) => {
+        const currentRuntime = this.runtimeByEntity.get(entityId);
+        if (!currentRuntime || currentRuntime.sourceToken !== sourceToken) {
+          return;
+        }
+        currentRuntime.pendingSources.delete(sourceUrl);
+        currentRuntime.importedSourceClips.delete(sourceUrl);
+        console.warn(`Failed to load animation source: ${sourceUrl}`, error);
+      });
+    }
+  }
+  release(entityId) {
+    const runtime = this.runtimeByEntity.get(entityId);
+    if (!runtime) {
+      return;
+    }
+    stopAllActions(runtime);
+    this.runtimeByEntity.delete(entityId);
+  }
+  update(world, deltaTime) {
+    const entityIds = world.query(AnimationComponent, ModelComponent);
+    const alive = new Set(entityIds);
+    for (const trackedEntityId of this.runtimeByEntity.keys()) {
+      if (!alive.has(trackedEntityId)) {
+        this.release(trackedEntityId);
+      }
+    }
+    const step = normalizeDeltaTime(deltaTime);
+    for (const entityId of entityIds) {
+      const animation = world.getComponent(entityId, AnimationComponent);
+      const model = world.getComponent(entityId, ModelComponent);
+      const root = model?.object ?? null;
+      if (!animation || !model || !root) {
+        this.release(entityId);
+        continue;
+      }
+      const existing = this.runtimeByEntity.get(entityId);
+      let runtime = existing;
+      if (!runtime || runtime.rootUuid !== root.uuid) {
+        if (runtime) {
+          stopAllActions(runtime);
+        }
+        const mixer = new THREE7.AnimationMixer(root);
+        const entries2 = readRuntimeClipEntries(animation);
+        const indexedActions = createActions(mixer, entries2);
+        runtime = {
+          rootUuid: root.uuid,
+          mixer,
+          actions: indexedActions.actions,
+          clipNameToIds: indexedActions.clipNameToIds,
+          activeClipId: null,
+          clipSignature: buildClipSignature(entries2),
+          sourceSignature: "",
+          sourceToken: 0,
+          importedSourceClips: /* @__PURE__ */ new Map(),
+          pendingSources: /* @__PURE__ */ new Set()
+        };
+        this.runtimeByEntity.set(entityId, runtime);
+      }
+      this.refreshExternalClipSources(world, entityId, animation, runtime);
+      applyPendingHydratedOptions(animation, runtime);
+      if (!world.isEntityVisible(entityId)) {
+        continue;
+      }
+      const entries = readRuntimeClipEntries(animation);
+      const clipSignature = buildClipSignature(entries);
+      if (runtime.clipSignature !== clipSignature) {
+        stopAllActions(runtime);
+        const indexedActions = createActions(runtime.mixer, entries);
+        runtime.actions = indexedActions.actions;
+        runtime.clipNameToIds = indexedActions.clipNameToIds;
+        runtime.clipSignature = clipSignature;
+      }
+      if (runtime.actions.size === 0) {
+        continue;
+      }
+      const activeState = animation.active;
+      const stateClipId = typeof activeState?.clipId === "string" && activeState.clipId.length > 0 ? activeState.clipId : null;
+      const stateClipName = activeState?.clip.name ?? null;
+      const fallbackClipId = stateClipName && runtime.clipNameToIds.has(stateClipName) ? runtime.clipNameToIds.get(stateClipName)?.[0] ?? null : null;
+      const nextClipId = stateClipId && runtime.actions.has(stateClipId) ? stateClipId : fallbackClipId && runtime.actions.has(fallbackClipId) ? fallbackClipId : null;
+      const hasActiveState = Boolean(activeState);
+      const isPaused = hasActiveState ? !(activeState?.isPlaying ?? false) : animation.paused;
+      if (hasActiveState) {
+        animation.paused = isPaused;
+      }
+      transitionToClip(
+        runtime,
+        nextClipId,
+        sanitizeCrossFadeDuration(animation.crossFadeDuration)
+      );
+      if (!runtime.activeClipId) {
+        continue;
+      }
+      const action = runtime.actions.get(runtime.activeClipId);
+      if (!action) {
+        continue;
+      }
+      applyActionState(action, animation, isPaused, Boolean(activeState?.loop));
+      if (animation.reverse && action.time <= 0) {
+        action.time = action.getClip().duration;
+      }
+      runtime.mixer.update(step);
+      if (activeState?.isPlaying) {
+        activeState.onPlaying();
+      }
+    }
+  }
+  dispose() {
+    for (const runtime of this.runtimeByEntity.values()) {
+      stopAllActions(runtime);
+    }
+    this.runtimeByEntity.clear();
+  }
+};
+__name(_AnimationSystem, "AnimationSystem");
+var AnimationSystem = _AnimationSystem;
+var MIN_NEAR = 1e-3;
+var MIN_FAR_DELTA = 1e-3;
+var MIN_FOV = 1;
+var MAX_FOV = 179;
+var MIN_ZOOM = 1e-3;
+function clampNear(value) {
+  if (!Number.isFinite(value)) {
+    return MIN_NEAR;
+  }
+  return Math.max(MIN_NEAR, value);
+}
+__name(clampNear, "clampNear");
+function clampFar(value, near) {
+  if (!Number.isFinite(value)) {
+    return near + 1e3;
+  }
+  return Math.max(near + MIN_FAR_DELTA, value);
+}
+__name(clampFar, "clampFar");
+function clampFov(value) {
+  if (!Number.isFinite(value)) {
+    return 50;
+  }
+  return Math.min(MAX_FOV, Math.max(MIN_FOV, value));
+}
+__name(clampFov, "clampFov");
+function clampZoom(value) {
+  if (!Number.isFinite(value)) {
+    return 1;
+  }
+  return Math.max(MIN_ZOOM, value);
+}
+__name(clampZoom, "clampZoom");
+function normalizeOrthoBounds(component) {
+  let left = Number.isFinite(component.left) ? component.left : -5;
+  let right = Number.isFinite(component.right) ? component.right : 5;
+  let top = Number.isFinite(component.top) ? component.top : 5;
+  let bottom = Number.isFinite(component.bottom) ? component.bottom : -5;
+  if (right <= left) {
+    right = left + 0.01;
+  }
+  if (top <= bottom) {
+    top = bottom + 0.01;
+  }
+  component.left = left;
+  component.right = right;
+  component.top = top;
+  component.bottom = bottom;
+}
+__name(normalizeOrthoBounds, "normalizeOrthoBounds");
+function isPerspectiveCamera(camera) {
+  return camera instanceof THREE7.PerspectiveCamera;
+}
+__name(isPerspectiveCamera, "isPerspectiveCamera");
+function isOrthographicCamera(camera) {
+  return camera instanceof THREE7.OrthographicCamera;
+}
+__name(isOrthographicCamera, "isOrthographicCamera");
+function readWindowAspect() {
+  if (typeof window === "undefined") {
+    return null;
+  }
+  const width = window.innerWidth;
+  const height = window.innerHeight;
+  if (Number.isFinite(width) && Number.isFinite(height) && width > 0 && height > 0) {
+    return width / height;
+  }
+  return null;
+}
+__name(readWindowAspect, "readWindowAspect");
+function buildSignature(component, camera, windowAspect) {
+  return [
+    component.type,
+    component.isDefault,
+    component.projection,
+    component.fov,
+    component.near,
+    component.far,
+    component.left,
+    component.right,
+    component.top,
+    component.bottom,
+    component.zoom,
+    windowAspect ?? "na",
+    camera.uuid
+  ].join("|");
+}
+__name(buildSignature, "buildSignature");
+var _CameraSyncSystem = class _CameraSyncSystem {
+  constructor() {
+    this.signatures = /* @__PURE__ */ new Map();
+  }
+  update(world) {
+    const entityIds = world.query(CameraComponent, Object3DRef);
+    const windowAspect = readWindowAspect();
+    const alive = new Set(entityIds);
+    for (const trackedId of this.signatures.keys()) {
+      if (!alive.has(trackedId)) {
+        this.signatures.delete(trackedId);
+      }
+    }
+    for (const entityId of entityIds) {
+      const component = world.getComponent(entityId, CameraComponent);
+      const objectRef = world.getComponent(entityId, Object3DRef);
+      if (!component || !objectRef) {
+        continue;
+      }
+      const camera = objectRef.object;
+      if (!(camera instanceof THREE7.Camera)) {
+        continue;
+      }
+      const nextSignature = buildSignature(component, camera, windowAspect);
+      if (this.signatures.get(entityId) === nextSignature) {
+        continue;
+      }
+      const near = clampNear(component.near);
+      const far = clampFar(component.far, near);
+      component.near = near;
+      component.far = far;
+      if (isPerspectiveCamera(camera)) {
+        camera.fov = clampFov(component.fov);
+        component.fov = camera.fov;
+        if (windowAspect !== null) {
+          camera.aspect = windowAspect;
+        }
+        camera.near = near;
+        camera.far = far;
+        camera.updateProjectionMatrix();
+      } else if (isOrthographicCamera(camera)) {
+        normalizeOrthoBounds(component);
+        camera.left = component.left;
+        camera.right = component.right;
+        camera.top = component.top;
+        camera.bottom = component.bottom;
+        camera.zoom = clampZoom(component.zoom);
+        component.zoom = camera.zoom;
+        camera.near = near;
+        camera.far = far;
+        camera.updateProjectionMatrix();
+      }
+      component.camera = camera;
+      this.signatures.set(entityId, buildSignature(component, camera, windowAspect));
+    }
+  }
+};
+__name(_CameraSyncSystem, "CameraSyncSystem");
+var CameraSyncSystem = _CameraSyncSystem;
+
+// core/systems/ObjectVisibilitySystem.ts
+var _ObjectVisibilitySystem = class _ObjectVisibilitySystem {
+  update(world) {
+    const entityIds = world.query(Object3DRef);
+    for (const entityId of entityIds) {
+      const objectRef = world.getComponent(entityId, Object3DRef);
+      const object = objectRef?.object;
+      if (!objectRef || !object) {
+        continue;
+      }
+      const targetVisibility = Boolean(objectRef.visibility);
+      if (object.visible !== targetVisibility) {
+        object.visible = targetVisibility;
+      }
+    }
+  }
+};
+__name(_ObjectVisibilitySystem, "ObjectVisibilitySystem");
+var ObjectVisibilitySystem = _ObjectVisibilitySystem;
+var MIN_FOG_DELTA = 1e-3;
+var MIN_DENSITY = 0;
+function createGradientTexture(effect, colors) {
+  if (typeof document === "undefined") {
+    const pixel = new Uint8Array([30, 30, 30, 255]);
+    const fallback = new THREE7.DataTexture(pixel, 1, 1, THREE7.RGBAFormat);
+    fallback.needsUpdate = true;
+    return fallback;
+  }
+  const canvas = document.createElement("canvas");
+  canvas.width = 512;
+  canvas.height = 512;
+  const context = canvas.getContext("2d");
+  if (!context) {
+    const fallback = new THREE7.CanvasTexture(canvas);
+    fallback.needsUpdate = true;
+    return fallback;
+  }
+  const safeColors = colors.length > 0 ? colors : ["#0f172a", "#334155"];
+  const lastIndex = Math.max(1, safeColors.length - 1);
+  let gradient;
+  if (effect === "radial") {
+    gradient = context.createRadialGradient(256, 256, 16, 256, 256, 320);
+  } else if (effect === "angular") {
+    gradient = context.createLinearGradient(0, 0, 512, 512);
+  } else {
+    gradient = context.createLinearGradient(0, 0, 0, 512);
+  }
+  for (let index = 0; index < safeColors.length; index += 1) {
+    gradient.addColorStop(index / lastIndex, safeColors[index]);
+  }
+  context.fillStyle = gradient;
+  context.fillRect(0, 0, 512, 512);
+  if (effect === "angular") {
+    context.globalCompositeOperation = "overlay";
+    const overlay = context.createRadialGradient(256, 256, 32, 256, 256, 340);
+    overlay.addColorStop(0, "rgba(255,255,255,0.25)");
+    overlay.addColorStop(1, "rgba(0,0,0,0.2)");
+    context.fillStyle = overlay;
+    context.fillRect(0, 0, 512, 512);
+    context.globalCompositeOperation = "source-over";
+  }
+  const texture = new THREE7.CanvasTexture(canvas);
+  texture.colorSpace = THREE7.SRGBColorSpace;
+  texture.needsUpdate = true;
+  return texture;
+}
+__name(createGradientTexture, "createGradientTexture");
+var _EnvironmentSyncSystem = class _EnvironmentSyncSystem {
+  constructor(scene) {
+    this.textureLoader = new THREE7.TextureLoader();
+    this.signature = null;
+    this.activeTexture = null;
+    this.pendingImageUrl = null;
+    this.scene = scene;
+  }
+  disposeActiveTexture() {
+    if (this.activeTexture) {
+      this.activeTexture.dispose();
+      this.activeTexture = null;
+    }
+  }
+  applySkybox(component) {
+    const skybox = component.values.skybox;
+    if (skybox.type === "none") {
+      this.disposeActiveTexture();
+      this.pendingImageUrl = null;
+      this.scene.background = null;
+      return;
+    }
+    if (skybox.type === "color") {
+      this.disposeActiveTexture();
+      this.pendingImageUrl = null;
+      this.scene.background = new THREE7.Color(skybox.color || "#1e1e1e");
+      return;
+    }
+    if (skybox.type === "gradient") {
+      this.disposeActiveTexture();
+      this.pendingImageUrl = null;
+      const texture = createGradientTexture(
+        skybox.gradient.effect,
+        skybox.gradient.colors
+      );
+      this.activeTexture = texture;
+      this.scene.background = texture;
+      return;
+    }
+    const imageUrl = skybox.imageUrl?.trim() ?? "";
+    if (!imageUrl) {
+      this.disposeActiveTexture();
+      this.pendingImageUrl = null;
+      this.scene.background = null;
+      return;
+    }
+    if (this.pendingImageUrl === imageUrl && this.activeTexture) {
+      this.scene.background = this.activeTexture;
+      return;
+    }
+    this.disposeActiveTexture();
+    this.pendingImageUrl = imageUrl;
+    this.textureLoader.load(
+      imageUrl,
+      (texture) => {
+        if (this.pendingImageUrl !== imageUrl) {
+          texture.dispose();
+          return;
+        }
+        texture.colorSpace = THREE7.SRGBColorSpace;
+        this.activeTexture = texture;
+        this.scene.background = texture;
+      },
+      void 0,
+      () => {
+        if (this.pendingImageUrl === imageUrl) {
+          this.pendingImageUrl = null;
+          this.scene.background = null;
+        }
+      }
+    );
+  }
+  applyFog(component) {
+    const fog = component.values.fog;
+    if (fog.type === "none") {
+      this.scene.fog = null;
+      return;
+    }
+    const fogColor = new THREE7.Color(fog.color || "#1e1e1e");
+    if (fog.type === "linear") {
+      const near = Number.isFinite(fog.linear.near) ? fog.linear.near : 1;
+      const farCandidate = Number.isFinite(fog.linear.far) ? fog.linear.far : near + 10;
+      const far = Math.max(near + MIN_FOG_DELTA, farCandidate);
+      this.scene.fog = new THREE7.Fog(fogColor, near, far);
+      return;
+    }
+    const density = Number.isFinite(fog.exponential.density) ? Math.max(MIN_DENSITY, fog.exponential.density) : 2e-3;
+    this.scene.fog = new THREE7.FogExp2(fogColor, density);
+  }
+  update(world) {
+    const entityIds = world.query(Environment);
+    if (entityIds.length === 0) {
+      if (this.signature !== null) {
+        this.signature = null;
+        this.pendingImageUrl = null;
+        this.disposeActiveTexture();
+        this.scene.background = null;
+        this.scene.fog = null;
+      }
+      return;
+    }
+    const entityId = entityIds[0];
+    const environment = world.getComponent(entityId, Environment);
+    if (!environment) {
+      return;
+    }
+    const nextSignature = JSON.stringify(environment.values);
+    if (this.signature === nextSignature) {
+      return;
+    }
+    this.signature = nextSignature;
+    this.applySkybox(environment);
+    this.applyFog(environment);
+  }
+  dispose() {
+    this.pendingImageUrl = null;
+    this.disposeActiveTexture();
+  }
+};
+__name(_EnvironmentSyncSystem, "EnvironmentSyncSystem");
+var EnvironmentSyncSystem = _EnvironmentSyncSystem;
+var _PostprocessingSyncSystem = class _PostprocessingSyncSystem {
+  constructor(renderer, scene, camera) {
+    this.signature = null;
+    this.composer = null;
+    this.composerEnabled = false;
+    this.renderer = renderer;
+    this.scene = scene;
+    this.camera = camera;
+  }
+  setComposerEnabled(enabled) {
+    this.composerEnabled = enabled;
+    this.scene.userData.ecsPostprocessingComposerActive = enabled;
+    if (!enabled) {
+      delete this.scene.userData.ecsPostprocessingComposer;
+    }
+  }
+  disposeComposer() {
+    if (!this.composer) {
+      this.setComposerEnabled(false);
+      return;
+    }
+    const maybeComposer = this.composer;
+    if (Array.isArray(maybeComposer.passes)) {
+      for (const pass of maybeComposer.passes) {
+        pass.dispose?.();
+      }
+    }
+    maybeComposer.dispose?.();
+    this.composer = null;
+    this.setComposerEnabled(false);
+  }
+  buildComposer(values) {
+    this.disposeComposer();
+    if (!values.postEnabled) {
+      return;
+    }
+    const composer = new EffectComposer(this.renderer);
+    composer.addPass(new RenderPass(this.scene, this.camera));
+    if (values.dof.enabled) {
+      composer.addPass(
+        new BokehPass(this.scene, this.camera, {
+          focus: values.dof.focusDistance,
+          aperture: Math.max(0, values.dof.focalLength),
+          maxblur: Math.max(0, values.dof.bokehScale)
+        })
+      );
+    }
+    if (values.bloom.enabled) {
+      const size = this.renderer.getSize(new THREE7.Vector2());
+      composer.addPass(
+        new UnrealBloomPass(
+          new THREE7.Vector2(size.width, size.height),
+          values.bloom.intensity,
+          values.bloom.radius,
+          values.bloom.threshold
+        )
+      );
+    }
+    if (values.vignette.enabled) {
+      const pass = new ShaderPass(VignetteShader);
+      const offset = pass.uniforms.offset;
+      const darkness = pass.uniforms.darkness;
+      if (offset) {
+        offset.value = values.vignette.offset;
+      }
+      if (darkness) {
+        darkness.value = values.vignette.darkness;
+      }
+      composer.addPass(pass);
+    }
+    if (values.hueSaturation.enabled) {
+      const pass = new ShaderPass(HueSaturationShader);
+      const hue = pass.uniforms.hue;
+      const saturation = pass.uniforms.saturation;
+      if (hue) {
+        hue.value = values.hueSaturation.hue;
+      }
+      if (saturation) {
+        saturation.value = values.hueSaturation.saturation;
+      }
+      composer.addPass(pass);
+    }
+    if (values.sepia.enabled) {
+      const pass = new ShaderPass(SepiaShader);
+      const amount = pass.uniforms.amount;
+      if (amount) {
+        amount.value = values.sepia.intensity;
+      }
+      composer.addPass(pass);
+    }
+    if (values.noise.enabled) {
+      composer.addPass(new FilmPass(values.noise.opacity));
+    }
+    if (values.dotScreen.enabled) {
+      composer.addPass(
+        new DotScreenPass(
+          new THREE7.Vector2(0, 0),
+          values.dotScreen.angle ?? values.dotScreen.dotScreenAngle,
+          values.dotScreen.scale ?? values.dotScreen.dotScreenScale
+        )
+      );
+    }
+    if (values.ssao.enabled) {
+      const pass = new SSAOPass(this.scene, this.camera);
+      pass.kernelRadius = values.ssao.radius;
+      pass.minDistance = 1e-3;
+      pass.maxDistance = Math.max(0.01, values.ssao.intensity);
+      composer.addPass(pass);
+    }
+    if (values.glitch.enabled) {
+      const pass = new GlitchPass();
+      pass.enabled = true;
+      pass.goWild = Boolean(values.glitch.active);
+      composer.addPass(pass);
+    }
+    composer.addPass(new OutputPass());
+    this.composer = composer;
+    this.scene.userData.ecsPostprocessingComposer = composer;
+    this.setComposerEnabled(true);
+  }
+  update(world) {
+    const entityIds = world.query(Postprocessing);
+    if (entityIds.length === 0) {
+      if (this.signature !== null) {
+        this.signature = null;
+        this.disposeComposer();
+        delete this.scene.userData.ecsPostprocessing;
+      }
+      return;
+    }
+    const postprocessing = world.getComponent(entityIds[0], Postprocessing);
+    if (!postprocessing) {
+      return;
+    }
+    const nextSignature = JSON.stringify(postprocessing.values);
+    if (this.signature === nextSignature) {
+      return;
+    }
+    this.signature = nextSignature;
+    this.buildComposer(postprocessing.values);
+    this.scene.userData.ecsPostprocessing = postprocessing.values;
+  }
+  dispose() {
+    this.signature = null;
+    this.disposeComposer();
+    delete this.scene.userData.ecsPostprocessing;
+    delete this.scene.userData.ecsPostprocessingComposerActive;
+    delete this.scene.userData.ecsPostprocessingComposer;
+  }
+};
+__name(_PostprocessingSyncSystem, "PostprocessingSyncSystem");
+var PostprocessingSyncSystem = _PostprocessingSyncSystem;
+var MIN_SIZE = 1e-4;
+function createRigidBodyDesc(RAPIER, bodyType) {
+  if (bodyType === "fixed") {
+    return RAPIER.RigidBodyDesc.fixed();
+  }
+  if (bodyType === "kinematicPosition") {
+    return RAPIER.RigidBodyDesc.kinematicPositionBased();
+  }
+  if (bodyType === "kinematicVelocity") {
+    return RAPIER.RigidBodyDesc.kinematicVelocityBased();
+  }
+  return RAPIER.RigidBodyDesc.dynamic();
+}
+__name(createRigidBodyDesc, "createRigidBodyDesc");
+function computeColliderState(colliderValues, object) {
+  if (!object) {
+    return colliderValues;
+  }
+  const scale = new THREE7.Vector3();
+  object.getWorldScale(scale);
+  return {
+    ...colliderValues,
+    size: {
+      x: Math.max(MIN_SIZE, colliderValues.size.x * Math.abs(scale.x || 1)),
+      y: Math.max(MIN_SIZE, colliderValues.size.y * Math.abs(scale.y || 1)),
+      z: Math.max(MIN_SIZE, colliderValues.size.z * Math.abs(scale.z || 1))
+    },
+    radius: Math.max(
+      MIN_SIZE,
+      colliderValues.radius * Math.max(Math.abs(scale.x || 1), Math.abs(scale.z || 1), 1)
+    ),
+    height: Math.max(MIN_SIZE, colliderValues.height * Math.abs(scale.y || 1))
+  };
+}
+__name(computeColliderState, "computeColliderState");
+function createColliderDesc(RAPIER, values, triMeshData) {
+  let desc;
+  if (values.shape === "trimesh" && triMeshData) {
+    desc = RAPIER.ColliderDesc.trimesh(
+      triMeshData.vertices,
+      triMeshData.indices
+    );
+  } else if (values.shape === "ball") {
+    desc = RAPIER.ColliderDesc.ball(Math.max(MIN_SIZE, values.radius));
+  } else if (values.shape === "capsule") {
+    desc = RAPIER.ColliderDesc.capsule(
+      Math.max(MIN_SIZE, values.height / 2),
+      Math.max(MIN_SIZE, values.radius)
+    );
+  } else if (values.shape === "cylinder") {
+    desc = RAPIER.ColliderDesc.cylinder(
+      Math.max(MIN_SIZE, values.height / 2),
+      Math.max(MIN_SIZE, values.radius)
+    );
+  } else {
+    desc = RAPIER.ColliderDesc.cuboid(
+      Math.max(MIN_SIZE, values.size.x / 2),
+      Math.max(MIN_SIZE, values.size.y / 2),
+      Math.max(MIN_SIZE, values.size.z / 2)
+    );
+  }
+  desc.setRestitution(Math.max(0, values.restitution));
+  desc.setFriction(Math.max(0, values.friction));
+  desc.setSensor(values.isSensor);
+  desc.setTranslation(
+    values.offsetPosition.x,
+    values.offsetPosition.y,
+    values.offsetPosition.z
+  );
+  const offsetQuaternion = new THREE7.Quaternion().setFromEuler(
+    new THREE7.Euler(
+      values.offsetRotation.x,
+      values.offsetRotation.y,
+      values.offsetRotation.z
+    )
+  );
+  desc.setRotation(offsetQuaternion);
+  return desc;
+}
+__name(createColliderDesc, "createColliderDesc");
+function findFirstMeshWithGeometry(object) {
+  if (object instanceof THREE7.Mesh && object.geometry) {
+    return object;
+  }
+  let found = null;
+  object.traverse((child) => {
+    if (found) {
+      return;
+    }
+    if (child instanceof THREE7.Mesh && child.geometry) {
+      found = child;
+    }
+  });
+  return found;
+}
+__name(findFirstMeshWithGeometry, "findFirstMeshWithGeometry");
+function createTriMeshData(object) {
+  if (!object) {
+    return null;
+  }
+  const mesh = findFirstMeshWithGeometry(object);
+  if (!mesh) {
+    return null;
+  }
+  const geometry = mesh.geometry;
+  const positionAttribute = geometry.getAttribute("position");
+  if (!positionAttribute || positionAttribute.itemSize < 3) {
+    return null;
+  }
+  const positionCount = positionAttribute.count;
+  if (positionCount < 3) {
+    return null;
+  }
+  object.updateWorldMatrix(true, true);
+  mesh.updateWorldMatrix(true, true);
+  const worldToObject = new THREE7.Matrix4().copy(object.matrixWorld).invert();
+  const relativeMatrix = new THREE7.Matrix4().multiplyMatrices(
+    worldToObject,
+    mesh.matrixWorld
+  );
+  const vertices = new Float32Array(positionCount * 3);
+  const point = new THREE7.Vector3();
+  for (let index = 0; index < positionCount; index += 1) {
+    point.set(
+      positionAttribute.getX(index),
+      positionAttribute.getY(index),
+      positionAttribute.getZ(index)
+    ).applyMatrix4(relativeMatrix);
+    const outputIndex = index * 3;
+    vertices[outputIndex] = point.x;
+    vertices[outputIndex + 1] = point.y;
+    vertices[outputIndex + 2] = point.z;
+  }
+  const indexAttribute = geometry.getIndex();
+  let indices;
+  if (indexAttribute) {
+    indices = new Uint32Array(indexAttribute.count);
+    for (let index = 0; index < indexAttribute.count; index += 1) {
+      indices[index] = indexAttribute.getX(index);
+    }
+  } else {
+    const triangleIndexCount = Math.floor(positionCount / 3) * 3;
+    if (triangleIndexCount < 3) {
+      return null;
+    }
+    indices = new Uint32Array(triangleIndexCount);
+    for (let index = 0; index < triangleIndexCount; index += 1) {
+      indices[index] = index;
+    }
+  }
+  const matrixSignature = relativeMatrix.elements.map((value) => value.toFixed(5)).join(",");
+  return {
+    vertices,
+    indices,
+    signature: `${mesh.uuid}:${geometry.uuid}:${positionCount}:${indices.length}:${matrixSignature}`
+  };
+}
+__name(createTriMeshData, "createTriMeshData");
+function syncBodyFromTransform(body, transform) {
+  const quaternion = new THREE7.Quaternion().setFromEuler(
+    new THREE7.Euler(transform.rotation.x, transform.rotation.y, transform.rotation.z)
+  );
+  body.setTranslation(
+    {
+      x: transform.position.x,
+      y: transform.position.y,
+      z: transform.position.z
+    },
+    true
+  );
+  body.setRotation(
+    {
+      x: quaternion.x,
+      y: quaternion.y,
+      z: quaternion.z,
+      w: quaternion.w
+    },
+    true
+  );
+}
+__name(syncBodyFromTransform, "syncBodyFromTransform");
+function syncTransformFromBody(transform, body) {
+  const position = body.translation();
+  const rotation = body.rotation();
+  transform.position.x = position.x;
+  transform.position.y = position.y;
+  transform.position.z = position.z;
+  const euler = new THREE7.Euler().setFromQuaternion(
+    new THREE7.Quaternion(rotation.x, rotation.y, rotation.z, rotation.w)
+  );
+  transform.rotation.x = euler.x;
+  transform.rotation.y = euler.y;
+  transform.rotation.z = euler.z;
+}
+__name(syncTransformFromBody, "syncTransformFromBody");
+var _PhysicsSyncSystem = class _PhysicsSyncSystem {
+  constructor(options) {
+    this.rigidBodyHandles = /* @__PURE__ */ new Map();
+    this.colliderHandles = /* @__PURE__ */ new Map();
+    this.rigidBodySignatures = /* @__PURE__ */ new Map();
+    this.colliderSignatures = /* @__PURE__ */ new Map();
+    this.rapier = null;
+    this.isBootstrappingWorld = false;
+    this.accumulator = 0;
+    this.isEditorMode = options?.isEditor ?? false;
+  }
+  async ensurePhysicsWorld(world) {
+    if (this.rapier || this.isBootstrappingWorld) {
+      return;
+    }
+    this.isBootstrappingWorld = true;
+    try {
+      const environmentEntityId = world.query(Environment)[0];
+      const environment = typeof environmentEntityId === "number" ? world.getComponent(environmentEntityId, Environment) : void 0;
+      const gravity = environment?.values.gravity;
+      const rapierWorld = await world.createPhysicsWorld({
+        gravity: {
+          x: gravity?.x,
+          y: gravity?.y,
+          z: gravity?.z
+        }
+      });
+      if (!rapierWorld) {
+        return;
+      }
+      const moduleValue = await world.getRapierModule();
+      this.rapier = moduleValue;
+    } finally {
+      this.isBootstrappingWorld = false;
+    }
+  }
+  removeEntityPhysics(physicsWorld, entityId) {
+    const rigidBodyHandle = this.rigidBodyHandles.get(entityId);
+    if (typeof rigidBodyHandle === "number") {
+      const rigidBody = physicsWorld.getRigidBody(rigidBodyHandle);
+      if (rigidBody) {
+        physicsWorld.removeRigidBody(rigidBody);
+      }
+    }
+    this.rigidBodyHandles.delete(entityId);
+    this.colliderHandles.delete(entityId);
+    this.rigidBodySignatures.delete(entityId);
+    this.colliderSignatures.delete(entityId);
+  }
+  update(world, deltaTime) {
+    if (!this.rapier || !world.getPhysicsWorld()) {
+      void this.ensurePhysicsWorld(world);
+      return;
+    }
+    const physicsWorld = world.getPhysicsWorld();
+    if (!physicsWorld) {
+      return;
+    }
+    const entities = world.query(TransformComponent, PhysicsComponent);
+    const activeEntities = new Set(entities);
+    for (const entityId of this.rigidBodyHandles.keys()) {
+      if (!activeEntities.has(entityId)) {
+        this.removeEntityPhysics(physicsWorld, entityId);
+      }
+    }
+    for (const entityId of entities) {
+      const transform = world.getComponent(entityId, TransformComponent);
+      const physics = world.getComponent(entityId, PhysicsComponent);
+      const object = world.getComponent(entityId, Object3DRef)?.object ?? null;
+      if (!transform || !physics) {
+        continue;
+      }
+      if (!physics.values.rigidbody.enabled) {
+        this.removeEntityPhysics(physicsWorld, entityId);
+        physics.rigidBody = null;
+        physics.collider = null;
+        continue;
+      }
+      const rigidBodySignature = JSON.stringify(physics.values.rigidbody);
+      const previousRigidBodySignature = this.rigidBodySignatures.get(entityId);
+      const hasRigidBody = this.rigidBodyHandles.has(entityId);
+      const shouldRecreateBody = !hasRigidBody || previousRigidBodySignature !== rigidBodySignature;
+      if (shouldRecreateBody) {
+        this.removeEntityPhysics(physicsWorld, entityId);
+        const lockTranslationX = physics.values.rigidbody.lockTranslations || physics.values.rigidbody.lockTranslationX;
+        const lockTranslationY = physics.values.rigidbody.lockTranslations || physics.values.rigidbody.lockTranslationY;
+        const lockTranslationZ = physics.values.rigidbody.lockTranslations || physics.values.rigidbody.lockTranslationZ;
+        const lockRotationX = physics.values.rigidbody.lockRotations || physics.values.rigidbody.lockRotationX;
+        const lockRotationY = physics.values.rigidbody.lockRotations || physics.values.rigidbody.lockRotationY;
+        const lockRotationZ = physics.values.rigidbody.lockRotations || physics.values.rigidbody.lockRotationZ;
+        const bodyType = this.isEditorMode ? "fixed" : physics.values.rigidbody.type;
+        const bodyDesc = createRigidBodyDesc(this.rapier, bodyType).setLinearDamping(physics.values.rigidbody.linearDamping).setAngularDamping(physics.values.rigidbody.angularDamping).setGravityScale(physics.values.rigidbody.gravityScale).setCanSleep(physics.values.rigidbody.canSleep).setCcdEnabled(physics.values.rigidbody.ccdEnabled).enabledTranslations(
+          !lockTranslationX,
+          !lockTranslationY,
+          !lockTranslationZ
+        ).enabledRotations(
+          !lockRotationX,
+          !lockRotationY,
+          !lockRotationZ
+        );
+        bodyDesc.setTranslation(
+          transform.position.x,
+          transform.position.y,
+          transform.position.z
+        );
+        const quaternion = new THREE7.Quaternion().setFromEuler(
+          new THREE7.Euler(
+            transform.rotation.x,
+            transform.rotation.y,
+            transform.rotation.z
+          )
+        );
+        bodyDesc.setRotation(quaternion);
+        const body2 = physicsWorld.createRigidBody(bodyDesc);
+        if (!this.isEditorMode && physics.values.rigidbody.type === "dynamic") {
+          body2.setAdditionalMass(physics.values.rigidbody.mass, true);
+        }
+        this.rigidBodyHandles.set(entityId, body2.handle);
+        this.rigidBodySignatures.set(entityId, rigidBodySignature);
+        physics.rigidBody = body2;
+      }
+      const rigidBodyHandle = this.rigidBodyHandles.get(entityId);
+      if (typeof rigidBodyHandle !== "number") {
+        continue;
+      }
+      const body = physicsWorld.getRigidBody(rigidBodyHandle);
+      if (!body) {
+        this.removeEntityPhysics(physicsWorld, entityId);
+        physics.rigidBody = null;
+        physics.collider = null;
+        continue;
+      }
+      physics.rigidBody = body;
+      if (this.isEditorMode || physics.values.rigidbody.type !== "dynamic") {
+        syncBodyFromTransform(body, transform);
+      }
+      const effectiveCollider = computeColliderState(physics.values.collider, object);
+      const triMeshData = effectiveCollider.shape === "trimesh" ? createTriMeshData(object) : null;
+      if (!effectiveCollider || !effectiveCollider.enabled) {
+        const colliderHandle = this.colliderHandles.get(entityId);
+        if (typeof colliderHandle === "number") {
+          const existingCollider = physicsWorld.getCollider(colliderHandle);
+          if (existingCollider) {
+            physicsWorld.removeCollider(existingCollider, true);
+          }
+        }
+        this.colliderHandles.delete(entityId);
+        this.colliderSignatures.delete(entityId);
+        physics.collider = null;
+        continue;
+      }
+      const colliderSignature = `${JSON.stringify(effectiveCollider)}:${triMeshData?.signature ?? ""}`;
+      const previousColliderSignature = this.colliderSignatures.get(entityId);
+      if (!this.colliderHandles.has(entityId) || previousColliderSignature !== colliderSignature) {
+        const previousColliderHandle = this.colliderHandles.get(entityId);
+        if (typeof previousColliderHandle === "number") {
+          const previousCollider = physicsWorld.getCollider(previousColliderHandle);
+          if (previousCollider) {
+            physicsWorld.removeCollider(previousCollider, true);
+          }
+        }
+        const colliderDesc = createColliderDesc(
+          this.rapier,
+          effectiveCollider,
+          triMeshData
+        );
+        const createdCollider = physicsWorld.createCollider(colliderDesc, body);
+        this.colliderHandles.set(entityId, createdCollider.handle);
+        this.colliderSignatures.set(entityId, colliderSignature);
+        physics.collider = createdCollider;
+      } else {
+        const colliderHandle = this.colliderHandles.get(entityId);
+        physics.collider = typeof colliderHandle === "number" ? physicsWorld.getCollider(colliderHandle) ?? null : null;
+      }
+    }
+    if (!this.isEditorMode) {
+      const environmentEntityId = world.query(Environment)[0];
+      const environment = typeof environmentEntityId === "number" ? world.getComponent(environmentEntityId, Environment) : void 0;
+      const fixedTimeStep = typeof environment?.values.fixedTimeStep === "number" && environment.values.fixedTimeStep > 0 ? environment.values.fixedTimeStep : 0.02;
+      const clampedDelta = Number.isFinite(deltaTime) && deltaTime > 0 ? Math.min(deltaTime, 0.1) : fixedTimeStep;
+      this.accumulator += clampedDelta;
+      while (this.accumulator >= fixedTimeStep) {
+        physicsWorld.integrationParameters.dt = fixedTimeStep;
+        physicsWorld.step();
+        this.accumulator -= fixedTimeStep;
+      }
+    }
+    for (const entityId of entities) {
+      const physics = world.getComponent(entityId, PhysicsComponent);
+      const transform = world.getComponent(entityId, TransformComponent);
+      if (!physics || !transform || this.isEditorMode || physics.values.rigidbody.type !== "dynamic") {
+        continue;
+      }
+      const rigidBodyHandle = this.rigidBodyHandles.get(entityId);
+      if (typeof rigidBodyHandle !== "number") {
+        continue;
+      }
+      const body = physicsWorld.getRigidBody(rigidBodyHandle);
+      if (!body) {
+        continue;
+      }
+      syncTransformFromBody(transform, body);
+    }
+  }
+  dispose(world) {
+    const physicsWorld = world.getPhysicsWorld();
+    if (physicsWorld) {
+      for (const entityId of this.rigidBodyHandles.keys()) {
+        this.removeEntityPhysics(physicsWorld, entityId);
+      }
+    }
+    this.rigidBodyHandles.clear();
+    this.colliderHandles.clear();
+    this.rigidBodySignatures.clear();
+    this.colliderSignatures.clear();
+    this.accumulator = 0;
+  }
+};
+__name(_PhysicsSyncSystem, "PhysicsSyncSystem");
+var PhysicsSyncSystem = _PhysicsSyncSystem;
+
+// core/systems/keyboardKeys.ts
+var KeyboardKeys = {
+  A: "a",
+  B: "b",
+  C: "c",
+  D: "d",
+  E: "e",
+  F: "f",
+  G: "g",
+  H: "h",
+  I: "i",
+  J: "j",
+  K: "k",
+  L: "l",
+  M: "m",
+  N: "n",
+  O: "o",
+  P: "p",
+  Q: "q",
+  R: "r",
+  S: "s",
+  T: "t",
+  U: "u",
+  V: "v",
+  W: "w",
+  X: "x",
+  Y: "y",
+  Z: "z",
+  Digit0: "0",
+  Digit1: "1",
+  Digit2: "2",
+  Digit3: "3",
+  Digit4: "4",
+  Digit5: "5",
+  Digit6: "6",
+  Digit7: "7",
+  Digit8: "8",
+  Digit9: "9",
+  Space: " ",
+  Enter: "enter",
+  Escape: "escape",
+  Tab: "tab",
+  Backspace: "backspace",
+  Delete: "delete",
+  Insert: "insert",
+  Home: "home",
+  End: "end",
+  PageUp: "pageup",
+  PageDown: "pagedown",
+  ArrowUp: "arrowup",
+  ArrowDown: "arrowdown",
+  ArrowLeft: "arrowleft",
+  ArrowRight: "arrowright",
+  Shift: "shift",
+  ShiftLeft: "shiftleft",
+  ShiftRight: "shiftright",
+  Control: "control",
+  ControlLeft: "controlleft",
+  ControlRight: "controlright",
+  Alt: "alt",
+  Meta: "meta",
+  CapsLock: "capslock",
+  NumLock: "numlock",
+  ScrollLock: "scrolllock",
+  Pause: "pause",
+  PrintScreen: "printscreen",
+  ContextMenu: "contextmenu",
+  Minus: "-",
+  Equal: "=",
+  BracketLeft: "[",
+  BracketRight: "]",
+  Backslash: "\\",
+  Semicolon: ";",
+  Quote: "'",
+  Backquote: "`",
+  Comma: ",",
+  Period: ".",
+  Slash: "/",
+  F1: "f1",
+  F2: "f2",
+  F3: "f3",
+  F4: "f4",
+  F5: "f5",
+  F6: "f6",
+  F7: "f7",
+  F8: "f8",
+  F9: "f9",
+  F10: "f10",
+  F11: "f11",
+  F12: "f12"
+};
+
+// core/systems/InputSystem.ts
+function normalizeKey(key) {
+  return key.toLowerCase();
+}
+__name(normalizeKey, "normalizeKey");
+function normalizeMouseButton(button) {
+  if (typeof button === "number") {
+    return button;
+  }
+  const normalized = button.toLowerCase();
+  if (normalized === "left") {
+    return 0;
+  }
+  if (normalized === "middle" || normalized === "scroll") {
+    return 1;
+  }
+  if (normalized === "right") {
+    return 2;
+  }
+  return Number.NaN;
+}
+__name(normalizeMouseButton, "normalizeMouseButton");
+var _InputSystem = class _InputSystem {
+  constructor() {
+    this.held = /* @__PURE__ */ new Set();
+    this.down = /* @__PURE__ */ new Set();
+    this.up = /* @__PURE__ */ new Set();
+    this.pendingDown = /* @__PURE__ */ new Set();
+    this.pendingUp = /* @__PURE__ */ new Set();
+    this.heldMouse = /* @__PURE__ */ new Set();
+    this.downMouse = /* @__PURE__ */ new Set();
+    this.upMouse = /* @__PURE__ */ new Set();
+    this.pendingMouseDown = /* @__PURE__ */ new Set();
+    this.pendingMouseUp = /* @__PURE__ */ new Set();
+    this.scrollDeltaX = 0;
+    this.scrollDeltaY = 0;
+    this.pendingScrollDeltaX = 0;
+    this.pendingScrollDeltaY = 0;
+    this.mouseDeltaX = 0;
+    this.mouseDeltaY = 0;
+    this.pendingMouseDeltaX = 0;
+    this.pendingMouseDeltaY = 0;
+    this.mousePosition = { x: 0, y: 0 };
+    this.pointerLockElement = null;
+    this.pendingPointerLockRequest = false;
+    this.onKeyDown = /* @__PURE__ */ __name((event) => {
+      const key = normalizeKey(event.key);
+      const code = normalizeKey(event.code);
+      if (!this.held.has(key)) {
+        this.pendingDown.add(key);
+      }
+      this.held.add(key);
+      if (code !== key) {
+        if (!this.held.has(code)) {
+          this.pendingDown.add(code);
+        }
+        this.held.add(code);
+      }
+    }, "onKeyDown");
+    this.onKeyUp = /* @__PURE__ */ __name((event) => {
+      const key = normalizeKey(event.key);
+      const code = normalizeKey(event.code);
+      this.held.delete(key);
+      this.pendingUp.add(key);
+      if (code !== key) {
+        this.held.delete(code);
+        this.pendingUp.add(code);
+      }
+    }, "onKeyUp");
+    this.onWindowBlur = /* @__PURE__ */ __name(() => {
+      this.clearAll();
+    }, "onWindowBlur");
+    this.onMouseDown = /* @__PURE__ */ __name((event) => {
+      const button = event.button;
+      if (!this.heldMouse.has(button)) {
+        this.pendingMouseDown.add(button);
+      }
+      this.heldMouse.add(button);
+      if (this.pendingPointerLockRequest) {
+        this.pendingPointerLockRequest = false;
+        const targetElement = this.pointerLockElement ?? document.body;
+        if (targetElement && typeof targetElement.requestPointerLock === "function") {
+          const result = targetElement.requestPointerLock();
+          if (result instanceof Promise) {
+            result.catch(() => {
+            });
+          }
+        }
+      }
+    }, "onMouseDown");
+    this.onMouseUp = /* @__PURE__ */ __name((event) => {
+      const button = event.button;
+      this.heldMouse.delete(button);
+      this.pendingMouseUp.add(button);
+    }, "onMouseUp");
+    this.onMouseWheel = /* @__PURE__ */ __name((event) => {
+      this.pendingScrollDeltaX += event.deltaX;
+      this.pendingScrollDeltaY += event.deltaY;
+    }, "onMouseWheel");
+    this.onMouseMove = /* @__PURE__ */ __name((event) => {
+      if (this.isMousePointerLocked()) {
+        this.pendingMouseDeltaX += event.movementX;
+        this.pendingMouseDeltaY += event.movementY;
+        this.mousePosition = {
+          x: this.mousePosition.x + event.movementX,
+          y: this.mousePosition.y + event.movementY
+        };
+        return;
+      }
+      this.pendingMouseDeltaX += event.movementX;
+      this.pendingMouseDeltaY += event.movementY;
+      this.mousePosition = {
+        x: event.clientX,
+        y: event.clientY
+      };
+    }, "onMouseMove");
+    this.onPointerLockChange = /* @__PURE__ */ __name(() => {
+      if (!this.isMousePointerLocked()) {
+        return;
+      }
+      const bounds = this.resolvePointerBounds();
+      this.mousePosition = {
+        x: (bounds.minX + bounds.maxX) / 2,
+        y: (bounds.minY + bounds.maxY) / 2
+      };
+    }, "onPointerLockChange");
+    this.onPointerLockError = /* @__PURE__ */ __name(() => {
+    }, "onPointerLockError");
+    if (typeof window === "undefined") {
+      return;
+    }
+    window.addEventListener("keydown", this.onKeyDown);
+    window.addEventListener("keyup", this.onKeyUp);
+    window.addEventListener("mousedown", this.onMouseDown);
+    window.addEventListener("mouseup", this.onMouseUp);
+    document.addEventListener("mousemove", this.onMouseMove);
+    window.addEventListener("wheel", this.onMouseWheel, { passive: true });
+    window.addEventListener("blur", this.onWindowBlur);
+    document.addEventListener("pointerlockchange", this.onPointerLockChange);
+    document.addEventListener("pointerlockerror", this.onPointerLockError);
+  }
+  resolvePointerBounds() {
+    const targetElement = this.pointerLockElement;
+    if (targetElement) {
+      const rect = targetElement.getBoundingClientRect();
+      return {
+        minX: rect.left,
+        minY: rect.top,
+        maxX: rect.right,
+        maxY: rect.bottom
+      };
+    }
+    return {
+      minX: 0,
+      minY: 0,
+      maxX: typeof window !== "undefined" ? window.innerWidth : 0,
+      maxY: typeof window !== "undefined" ? window.innerHeight : 0
+    };
+  }
+  setPointerLockElement(element) {
+    this.pointerLockElement = element;
+  }
+  lockMousePointer() {
+    if (typeof document === "undefined") {
+      return false;
+    }
+    const targetElement = this.pointerLockElement ?? document.body;
+    if (!targetElement || typeof targetElement.requestPointerLock !== "function") {
+      return false;
+    }
+    try {
+      const result = targetElement.requestPointerLock();
+      if (result instanceof Promise) {
+        result.catch(() => {
+          this.pendingPointerLockRequest = true;
+        });
+      }
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  unlockMousePointer() {
+    if (typeof document === "undefined") {
+      return false;
+    }
+    this.pendingPointerLockRequest = false;
+    if (!document.pointerLockElement || typeof document.exitPointerLock !== "function") {
+      return false;
+    }
+    document.exitPointerLock();
+    return true;
+  }
+  isMousePointerLocked() {
+    if (typeof document === "undefined") {
+      return false;
+    }
+    const activePointerLockElement = document.pointerLockElement;
+    if (!activePointerLockElement) {
+      return false;
+    }
+    if (!this.pointerLockElement) {
+      return true;
+    }
+    return activePointerLockElement === this.pointerLockElement;
+  }
+  getKey(key) {
+    return this.held.has(normalizeKey(key));
+  }
+  getKeyDown(key) {
+    return this.down.has(normalizeKey(key));
+  }
+  getKeyUp(key) {
+    return this.up.has(normalizeKey(key));
+  }
+  consumePressed(key) {
+    const normalized = normalizeKey(key);
+    if (!this.down.has(normalized)) {
+      return false;
+    }
+    this.down.delete(normalized);
+    return true;
+  }
+  getMouse(button) {
+    const normalizedButton = normalizeMouseButton(button);
+    if (!Number.isInteger(normalizedButton)) {
+      return false;
+    }
+    return this.heldMouse.has(normalizedButton);
+  }
+  getMouseDown(button) {
+    const normalizedButton = normalizeMouseButton(button);
+    if (!Number.isInteger(normalizedButton)) {
+      return false;
+    }
+    return this.downMouse.has(normalizedButton);
+  }
+  getMouseUp(button) {
+    const normalizedButton = normalizeMouseButton(button);
+    if (!Number.isInteger(normalizedButton)) {
+      return false;
+    }
+    return this.upMouse.has(normalizedButton);
+  }
+  getScrollClick() {
+    return this.getMouse("middle");
+  }
+  getScrollClickDown() {
+    return this.getMouseDown("middle");
+  }
+  getScrollClickUp() {
+    return this.getMouseUp("middle");
+  }
+  getScrollDelta() {
+    return {
+      x: this.scrollDeltaX,
+      y: this.scrollDeltaY
+    };
+  }
+  consumeScrollDelta() {
+    const delta = this.getScrollDelta();
+    this.scrollDeltaX = 0;
+    this.scrollDeltaY = 0;
+    return delta;
+  }
+  getMousePosition() {
+    return {
+      x: this.mousePosition.x,
+      y: this.mousePosition.y
+    };
+  }
+  getMouseDelta() {
+    return {
+      x: this.mouseDeltaX,
+      y: this.mouseDeltaY
+    };
+  }
+  consumeMouseDelta() {
+    const delta = this.getMouseDelta();
+    this.mouseDeltaX = 0;
+    this.mouseDeltaY = 0;
+    return delta;
+  }
+  update(_world, _deltaTime) {
+    this.down.clear();
+    this.up.clear();
+    this.downMouse.clear();
+    this.upMouse.clear();
+    this.scrollDeltaX = this.pendingScrollDeltaX;
+    this.scrollDeltaY = this.pendingScrollDeltaY;
+    this.mouseDeltaX = this.pendingMouseDeltaX;
+    this.mouseDeltaY = this.pendingMouseDeltaY;
+    for (const key of this.pendingDown) {
+      this.down.add(key);
+    }
+    for (const key of this.pendingUp) {
+      this.up.add(key);
+    }
+    for (const button of this.pendingMouseDown) {
+      this.downMouse.add(button);
+    }
+    for (const button of this.pendingMouseUp) {
+      this.upMouse.add(button);
+    }
+    this.pendingDown.clear();
+    this.pendingUp.clear();
+    this.pendingMouseDown.clear();
+    this.pendingMouseUp.clear();
+    this.pendingScrollDeltaX = 0;
+    this.pendingScrollDeltaY = 0;
+    this.pendingMouseDeltaX = 0;
+    this.pendingMouseDeltaY = 0;
+  }
+  dispose() {
+    if (typeof window !== "undefined") {
+      window.removeEventListener("keydown", this.onKeyDown);
+      window.removeEventListener("keyup", this.onKeyUp);
+      window.removeEventListener("mousedown", this.onMouseDown);
+      window.removeEventListener("mouseup", this.onMouseUp);
+      document.removeEventListener("mousemove", this.onMouseMove);
+      window.removeEventListener("wheel", this.onMouseWheel);
+      window.removeEventListener("blur", this.onWindowBlur);
+      document.removeEventListener("pointerlockchange", this.onPointerLockChange);
+      document.removeEventListener("pointerlockerror", this.onPointerLockError);
+    }
+    this.clearAll();
+  }
+  clearAll() {
+    this.held.clear();
+    this.down.clear();
+    this.up.clear();
+    this.pendingDown.clear();
+    this.pendingUp.clear();
+    this.heldMouse.clear();
+    this.downMouse.clear();
+    this.upMouse.clear();
+    this.pendingMouseDown.clear();
+    this.pendingMouseUp.clear();
+    this.scrollDeltaX = 0;
+    this.scrollDeltaY = 0;
+    this.pendingScrollDeltaX = 0;
+    this.pendingScrollDeltaY = 0;
+    this.mouseDeltaX = 0;
+    this.mouseDeltaY = 0;
+    this.pendingMouseDeltaX = 0;
+    this.pendingMouseDeltaY = 0;
+    this.mousePosition = { x: 0, y: 0 };
+  }
+};
+__name(_InputSystem, "InputSystem");
+var InputSystem = _InputSystem;
+var MIN_LIGHT_DISTANCE = 0;
+var MIN_LIGHT_INTENSITY = 0;
+var MIN_AREA_SIZE = 0.01;
+function applyLightValues(lightComponent) {
+  const { light, values } = lightComponent;
+  if (typeof values.color === "string") {
+    light.color.set(values.color);
+  }
+  if (Number.isFinite(values.intensity)) {
+    light.intensity = Math.max(MIN_LIGHT_INTENSITY, values.intensity);
+  }
+  light.frustumCulled = Boolean(values.frustumCulling);
+  if ("castShadow" in light) {
+    light.castShadow = Boolean(
+      values.castShadow
+    );
+  }
+  if (light instanceof THREE7.PointLight) {
+    if (typeof values.distance === "number" && Number.isFinite(values.distance)) {
+      light.distance = Math.max(MIN_LIGHT_DISTANCE, values.distance);
+    }
+    if (typeof values.decay === "number" && Number.isFinite(values.decay)) {
+      light.decay = Math.max(0, values.decay);
+    }
+  }
+  if (light instanceof THREE7.SpotLight) {
+    if (typeof values.distance === "number" && Number.isFinite(values.distance)) {
+      light.distance = Math.max(MIN_LIGHT_DISTANCE, values.distance);
+    }
+    if (typeof values.decay === "number" && Number.isFinite(values.decay)) {
+      light.decay = Math.max(0, values.decay);
+    }
+    if (typeof values.angle === "number" && Number.isFinite(values.angle)) {
+      light.angle = Math.max(0, Math.min(Math.PI / 2, values.angle));
+    }
+    if (typeof values.penumbra === "number" && Number.isFinite(values.penumbra)) {
+      light.penumbra = Math.max(0, Math.min(1, values.penumbra));
+    }
+  }
+  if (light instanceof THREE7.RectAreaLight) {
+    if (typeof values.width === "number" && Number.isFinite(values.width)) {
+      light.width = Math.max(MIN_AREA_SIZE, values.width);
+    }
+    if (typeof values.height === "number" && Number.isFinite(values.height)) {
+      light.height = Math.max(MIN_AREA_SIZE, values.height);
+    }
+  }
+}
+__name(applyLightValues, "applyLightValues");
+var _LightSyncSystem = class _LightSyncSystem {
+  constructor() {
+    this.signatures = /* @__PURE__ */ new Map();
+  }
+  update(world) {
+    const entityIds = world.query(LightComponent);
+    const alive = new Set(entityIds);
+    for (const trackedId of this.signatures.keys()) {
+      if (!alive.has(trackedId)) {
+        this.signatures.delete(trackedId);
+      }
+    }
+    for (const entityId of entityIds) {
+      const lightComponent = world.getComponent(entityId, LightComponent);
+      if (!lightComponent) {
+        continue;
+      }
+      const signature = JSON.stringify(lightComponent.values);
+      if (this.signatures.get(entityId) === signature) {
+        continue;
+      }
+      applyLightValues(lightComponent);
+      this.signatures.set(entityId, signature);
+    }
+  }
+};
+__name(_LightSyncSystem, "LightSyncSystem");
+var LightSyncSystem = _LightSyncSystem;
+var materialTextureKeyMap = {
+  textureMap: "map",
+  alphaTextureMap: "alphaMap"
+};
+var materialTextureSlots = [
+  "map",
+  "alphaMap",
+  "normalMap",
+  "roughnessMap",
+  "metalnessMap",
+  "aoMap",
+  "emissiveMap",
+  "bumpMap",
+  "displacementMap",
+  "lightMap",
+  "envMap"
+];
+function resolveMaterialPropertyKey(key) {
+  return materialTextureKeyMap[key] ?? key;
+}
+__name(resolveMaterialPropertyKey, "resolveMaterialPropertyKey");
+function createMaterialByType(type) {
+  if (type === "basic") {
+    return new THREE7.MeshBasicMaterial();
+  }
+  if (type === "phong") {
+    return new THREE7.MeshPhongMaterial();
+  }
+  if (type === "physical") {
+    return new THREE7.MeshPhysicalMaterial();
+  }
+  return new THREE7.MeshStandardMaterial();
+}
+__name(createMaterialByType, "createMaterialByType");
+function replaceMaterialAcrossObject(object, previous, next) {
+  object.traverse((child) => {
+    const mesh = child;
+    const currentMaterial = mesh.material;
+    if (!currentMaterial) {
+      return;
+    }
+    if (Array.isArray(currentMaterial)) {
+      let changed = false;
+      const updated = currentMaterial.map((material) => {
+        if (material === previous) {
+          changed = true;
+          return next;
+        }
+        return material;
+      });
+      if (changed) {
+        mesh.material = updated;
+      }
+      return;
+    }
+    if (currentMaterial === previous) {
+      mesh.material = next;
+    }
+  });
+}
+__name(replaceMaterialAcrossObject, "replaceMaterialAcrossObject");
+function extractObjectMaterials(object) {
+  const materials = [];
+  object.traverse((child) => {
+    const mesh = child;
+    const currentMaterial = mesh.material;
+    if (!currentMaterial) {
+      return;
+    }
+    const addMaterial = /* @__PURE__ */ __name((material) => {
+      if (!materials.includes(material)) {
+        materials.push(material);
+      }
+    }, "addMaterial");
+    if (Array.isArray(currentMaterial)) {
+      for (const material of currentMaterial) {
+        addMaterial(material);
+      }
+      return;
+    }
+    addMaterial(currentMaterial);
+  });
+  return materials;
+}
+__name(extractObjectMaterials, "extractObjectMaterials");
+function applyTextureFiltering(material, filtering) {
+  const sharp = filtering === "sharp";
+  const target = material;
+  for (const slot of materialTextureSlots) {
+    const texture = target[slot];
+    if (!texture || !(texture instanceof THREE7.Texture)) {
+      continue;
+    }
+    const useMipmaps = texture.generateMipmaps !== false;
+    texture.magFilter = sharp ? THREE7.NearestFilter : THREE7.LinearFilter;
+    texture.minFilter = useMipmaps ? sharp ? THREE7.NearestMipmapNearestFilter : THREE7.LinearMipmapLinearFilter : sharp ? THREE7.NearestFilter : THREE7.LinearFilter;
+    texture.needsUpdate = true;
+  }
+  material.needsUpdate = true;
+}
+__name(applyTextureFiltering, "applyTextureFiltering");
+function setTextureMipmaps(material, enabled) {
+  const target = material;
+  for (const slot of materialTextureSlots) {
+    const texture = target[slot];
+    if (!texture || !(texture instanceof THREE7.Texture)) {
+      continue;
+    }
+    texture.generateMipmaps = enabled;
+    const sharp = texture.magFilter === THREE7.NearestFilter;
+    texture.minFilter = enabled ? sharp ? THREE7.NearestMipmapNearestFilter : THREE7.LinearMipmapLinearFilter : sharp ? THREE7.NearestFilter : THREE7.LinearFilter;
+    texture.needsUpdate = true;
+  }
+  material.needsUpdate = true;
+}
+__name(setTextureMipmaps, "setTextureMipmaps");
+function assignMaterialTexture(material, rawKey, url, textureCache) {
+  const target = material;
+  const key = resolveMaterialPropertyKey(rawKey);
+  let texture = textureCache.get(url);
+  if (!texture) {
+    texture = new THREE7.TextureLoader().load(url);
+    textureCache.set(url, texture);
+  }
+  target[key] = texture;
+}
+__name(assignMaterialTexture, "assignMaterialTexture");
+function clearMaterialTexture(material, rawKey) {
+  const target = material;
+  const key = resolveMaterialPropertyKey(rawKey);
+  target[key] = null;
+}
+__name(clearMaterialTexture, "clearMaterialTexture");
+function applyMaterialState(material, value, textureCache) {
+  const target = material;
+  if (target.color && typeof target.color.set === "function") {
+    target.color.set(value.color);
+  }
+  if (typeof target.roughness === "number") {
+    target.roughness = value.roughness;
+  }
+  if (typeof target.metalness === "number") {
+    target.metalness = value.metalness;
+  }
+  if (target.normalScale && typeof target.normalScale.set === "function") {
+    target.normalScale.set(
+      value.normalScale,
+      value.normalScale
+    );
+  }
+  target.opacity = value.opacity;
+  if (target.emissive && typeof target.emissive.set === "function") {
+    target.emissive.set(value.emissive);
+  }
+  if (typeof target.emissiveIntensity === "number") {
+    target.emissiveIntensity = value.emissiveIntensity;
+  }
+  target.side = value.side;
+  target.blending = value.blending;
+  target.depthTest = value.depthTest;
+  target.depthWrite = value.depthWrite;
+  target.wireframe = value.wireframe;
+  target.transparent = value.transparent;
+  const textureEntries = [
+    ["textureMap", value.textureMap],
+    ["alphaTextureMap", value.alphaTextureMap],
+    ["normalMap", value.normalMap],
+    ["roughnessMap", value.roughnessMap],
+    ["metalnessMap", value.metalnessMap],
+    ["aoMap", value.aoMap],
+    ["emissiveMap", value.emissiveMap],
+    ["bumpMap", value.bumpMap],
+    ["displacementMap", value.displacementMap],
+    ["lightMap", value.lightMap],
+    ["envMap", value.envMap]
+  ];
+  for (const [key, url] of textureEntries) {
+    if (typeof url === "string" && url.length > 0) {
+      assignMaterialTexture(material, key, url, textureCache);
+    } else {
+      clearMaterialTexture(material, key);
+    }
+  }
+  applyTextureFiltering(material, value.textureFiltering);
+  setTextureMipmaps(material, value.useMipmaps);
+  material.needsUpdate = true;
+}
+__name(applyMaterialState, "applyMaterialState");
+var _MaterialSyncSystem = class _MaterialSyncSystem {
+  constructor() {
+    this.signatures = /* @__PURE__ */ new Map();
+    this.textureCache = /* @__PURE__ */ new Map();
+  }
+  update(world) {
+    const entityIds = world.query(MaterialComponent);
+    const alive = new Set(entityIds);
+    for (const trackedId of this.signatures.keys()) {
+      if (!alive.has(trackedId)) {
+        this.signatures.delete(trackedId);
+      }
+    }
+    for (const entityId of entityIds) {
+      const materialComponent = world.getComponent(
+        entityId,
+        MaterialComponent
+      );
+      if (!materialComponent) {
+        continue;
+      }
+      const signature = JSON.stringify(materialComponent.values);
+      if (this.signatures.get(entityId) === signature) {
+        continue;
+      }
+      const object = world.getComponent(entityId, Object3DRef)?.object;
+      const objectMaterials = object ? extractObjectMaterials(object) : [];
+      for (let index = 0; index < materialComponent.values.length; index += 1) {
+        const value = materialComponent.values[index];
+        if (!value) {
+          continue;
+        }
+        const previousMaterial = materialComponent.materials[index];
+        if (!previousMaterial) {
+          continue;
+        }
+        if (object) {
+          const currentObjectMaterial = objectMaterials[index];
+          if (currentObjectMaterial && currentObjectMaterial !== previousMaterial) {
+            replaceMaterialAcrossObject(
+              object,
+              currentObjectMaterial,
+              previousMaterial
+            );
+            objectMaterials[index] = previousMaterial;
+          }
+        }
+        const nextType = createMaterialByType(value.type).type;
+        let targetMaterial = previousMaterial;
+        if (previousMaterial.type !== nextType) {
+          const replacement = createMaterialByType(value.type);
+          if (object) {
+            replaceMaterialAcrossObject(object, previousMaterial, replacement);
+            objectMaterials[index] = replacement;
+          }
+          materialComponent.materials[index] = replacement;
+          targetMaterial = replacement;
+          if (index === 0) {
+            materialComponent.material = replacement;
+          }
+          previousMaterial.dispose();
+        }
+        applyMaterialState(targetMaterial, value, this.textureCache);
+      }
+      this.signatures.set(entityId, JSON.stringify(materialComponent.values));
+    }
+  }
+  dispose() {
+    for (const texture of this.textureCache.values()) {
+      texture.dispose();
+    }
+    this.textureCache.clear();
+    this.signatures.clear();
+  }
+};
+__name(_MaterialSyncSystem, "MaterialSyncSystem");
+var MaterialSyncSystem = _MaterialSyncSystem;
+var MIN_DIMENSION = 0.01;
+var MIN_RADIUS = 1e-3;
+function sanitizeDimension(value) {
+  return Number.isFinite(value) ? Math.max(MIN_DIMENSION, value) : MIN_DIMENSION;
+}
+__name(sanitizeDimension, "sanitizeDimension");
+function sanitizeRadius(value) {
+  return Number.isFinite(value) ? Math.max(MIN_RADIUS, value) : MIN_RADIUS;
+}
+__name(sanitizeRadius, "sanitizeRadius");
+function sanitizeMeshParameters(component) {
+  switch (component.kind) {
+    case "cube": {
+      const params = component.parameters;
+      const fallback = DEFAULT_MESH_GEOMETRY_PARAMETERS.cube;
+      return {
+        width: sanitizeDimension(params.width ?? fallback.width),
+        height: sanitizeDimension(params.height ?? fallback.height),
+        depth: sanitizeDimension(params.depth ?? fallback.depth)
+      };
+    }
+    case "plane": {
+      const params = component.parameters;
+      const fallback = DEFAULT_MESH_GEOMETRY_PARAMETERS.plane;
+      return {
+        width: sanitizeDimension(params.width ?? fallback.width),
+        height: sanitizeDimension(params.height ?? fallback.height)
+      };
+    }
+    case "sphere": {
+      const params = component.parameters;
+      const fallback = DEFAULT_MESH_GEOMETRY_PARAMETERS.sphere;
+      return {
+        radius: sanitizeRadius(params.radius ?? fallback.radius)
+      };
+    }
+    case "cylinder":
+    case "capsule": {
+      const params = component.parameters;
+      const fallback = component.kind === "cylinder" ? DEFAULT_MESH_GEOMETRY_PARAMETERS.cylinder : DEFAULT_MESH_GEOMETRY_PARAMETERS.capsule;
+      return {
+        radius: sanitizeRadius(params.radius ?? fallback.radius),
+        height: sanitizeDimension(params.height ?? fallback.height)
+      };
+    }
+    case "model":
+      return {};
+  }
+}
+__name(sanitizeMeshParameters, "sanitizeMeshParameters");
+function resolvePrimaryMesh(object) {
+  if (!object) {
+    return null;
+  }
+  if (object instanceof THREE7.Mesh) {
+    return object;
+  }
+  let found = null;
+  object.traverse((child) => {
+    if (!found && child instanceof THREE7.Mesh) {
+      found = child;
+    }
+  });
+  return found;
+}
+__name(resolvePrimaryMesh, "resolvePrimaryMesh");
+function applyGeometry(component) {
+  if (component.kind === "model") {
+    return;
+  }
+  const mesh = resolvePrimaryMesh(component.object);
+  if (!mesh) {
+    return;
+  }
+  const sanitized = sanitizeMeshParameters(component);
+  component.parameters = sanitized;
+  let nextGeometry;
+  switch (component.kind) {
+    case "cube": {
+      const params = sanitized;
+      nextGeometry = new THREE7.BoxGeometry(params.width, params.height, params.depth);
+      break;
+    }
+    case "plane": {
+      const params = sanitized;
+      nextGeometry = new THREE7.PlaneGeometry(params.width, params.height);
+      break;
+    }
+    case "sphere": {
+      const params = sanitized;
+      nextGeometry = new THREE7.SphereGeometry(params.radius, 24, 24);
+      break;
+    }
+    case "cylinder": {
+      const params = sanitized;
+      nextGeometry = new THREE7.CylinderGeometry(
+        params.radius,
+        params.radius,
+        params.height,
+        20
+      );
+      break;
+    }
+    case "capsule": {
+      const params = sanitized;
+      nextGeometry = new THREE7.CapsuleGeometry(params.radius, params.height, 4, 8);
+      break;
+    }
+    default:
+      return;
+  }
+  const previousGeometry = mesh.geometry;
+  mesh.geometry = nextGeometry;
+  previousGeometry.dispose();
+}
+__name(applyGeometry, "applyGeometry");
+function applyShadowFlags(component) {
+  if (!component.object) {
+    return;
+  }
+  component.object.traverse((child) => {
+    if (child instanceof THREE7.Mesh) {
+      child.castShadow = component.castShadow;
+      child.receiveShadow = component.receiveShadow;
+    }
+  });
+}
+__name(applyShadowFlags, "applyShadowFlags");
+var _MeshGeometrySystem = class _MeshGeometrySystem {
+  constructor() {
+    this.geometrySignatures = /* @__PURE__ */ new Map();
+    this.shadowSignatures = /* @__PURE__ */ new Map();
+  }
+  update(world) {
+    const entityIds = world.query(MeshGeometryComponent);
+    const alive = new Set(entityIds);
+    for (const trackedId of this.geometrySignatures.keys()) {
+      if (!alive.has(trackedId)) {
+        this.geometrySignatures.delete(trackedId);
+        this.shadowSignatures.delete(trackedId);
+      }
+    }
+    for (const entityId of entityIds) {
+      const meshGeometry = world.getComponent(
+        entityId,
+        MeshGeometryComponent
+      );
+      if (!meshGeometry) {
+        continue;
+      }
+      if (!meshGeometry.object) {
+        const objectRef = world.getComponent(entityId, Object3DRef);
+        if (objectRef?.object) {
+          meshGeometry.object = objectRef.object;
+        }
+      }
+      const geometrySignature = `${meshGeometry.kind}:${JSON.stringify(meshGeometry.parameters)}:${meshGeometry.object?.uuid ?? ""}`;
+      const shadowSignature = `${meshGeometry.castShadow}:${meshGeometry.receiveShadow}:${meshGeometry.object?.uuid ?? ""}`;
+      if (this.geometrySignatures.get(entityId) !== geometrySignature) {
+        applyGeometry(meshGeometry);
+        this.geometrySignatures.set(
+          entityId,
+          `${meshGeometry.kind}:${JSON.stringify(meshGeometry.parameters)}:${meshGeometry.object?.uuid ?? ""}`
+        );
+      }
+      if (this.shadowSignatures.get(entityId) !== shadowSignature) {
+        applyShadowFlags(meshGeometry);
+        this.shadowSignatures.set(entityId, shadowSignature);
+      }
+    }
+  }
+};
+__name(_MeshGeometrySystem, "MeshGeometrySystem");
+var MeshGeometrySystem = _MeshGeometrySystem;
+
+// core/systems/RenderSystem.ts
+var _RenderSystem = class _RenderSystem {
+  constructor(renderer, scene, camera, afterRender) {
+    this.renderer = renderer;
+    this.scene = scene;
+    this.camera = camera;
+    this.afterRender = afterRender;
+  }
+  update(_world) {
+    if (this.scene.userData.ecsPostprocessingComposerActive === true) {
+      const composer = this.scene.userData.ecsPostprocessingComposer;
+      if (composer) {
+        const width = Math.max(1, this.renderer.domElement.clientWidth);
+        const height = Math.max(1, this.renderer.domElement.clientHeight);
+        composer.setSize(width, height);
+        composer.render();
+      } else {
+        this.renderer.render(this.scene, this.camera);
+      }
+      this.afterRender?.();
+      return;
+    }
+    this.renderer.render(this.scene, this.camera);
+    this.afterRender?.();
+  }
+};
+__name(_RenderSystem, "RenderSystem");
+var RenderSystem = _RenderSystem;
+var _Behaviour = class _Behaviour {
+  /**
+   * Engine-managed constructor. Hosts (`ScriptBehaviourSystem`) instantiate
+   * subclasses with the owning world, the entity id, and the script's `data`
+   * payload. User code should not call this directly.
+   *
+   * @param world - The owning ECS world.
+   * @param entityId - The entity this script is bound to.
+   * @param component - The `ScriptComponent.data` payload, or any object that
+   *   should be exposed to the script as `this.data`.
+   */
+  constructor(world, entityId, component) {
+    /**
+     * Inspector-bound payload from the entity's `ScriptComponent`. Override the
+     * type on subclasses with `declare data: MyDataShape` to get type safety
+     * inside hooks. Saved with the project so values persist across reloads.
+     */
+    this.data = {};
+    /**
+     * Seconds elapsed since the last frame. Set by the engine before each
+     * {@link Behaviour.onUpdate}.
+     */
+    this.deltaTime = 0;
+    this.world = world;
+    this.entityId = entityId;
+    if (component) this.data = component;
+    this.entity = this.getEntity();
+    this.threeRef = this.getComponent(Object3DRef);
+    this.transform = this.getComponent(TransformComponent);
+  }
+  /**
+   * Engine-managed per-frame entry point. Refreshes {@link Behaviour.deltaTime}
+   * and delegates to {@link Behaviour.onUpdate}.
+   *
+   * @remarks Do **not** override this method — override
+   * {@link Behaviour.onUpdate} instead.
+   *
+   * @param world - The owning world (may differ from the constructor world
+   *   after hot reload).
+   * @param deltaTime - Seconds since the last frame.
+   */
+  update(world, deltaTime) {
+    this.deltaTime = deltaTime;
+    this.world = world;
+    this.onUpdate();
+  }
+  /**
+   * Optional cleanup hook invoked when the script is detached or the entity
+   * is destroyed. Override to release timers, listeners, or other resources.
+   *
+   * @param world - The owning world at disposal time.
+   */
+  dispose(world) {
+  }
+  /**
+   * Returns the entity's world-space position as a new `THREE.Vector3`, or
+   * `null` if the entity has no scene presence.
+   */
+  getWorldPosition() {
+    if (!this.threeRef) {
+      return null;
+    }
+    const position = new THREE7.Vector3();
+    this.threeRef.object.getWorldPosition(position);
+    return position;
+  }
+  /**
+   * Returns the entity's forward direction in world space (the +Z axis of its
+   * world matrix), or `null` if the entity has no scene presence.
+   */
+  getWorldDirection() {
+    if (!this.threeRef) {
+      return null;
+    }
+    const target = new THREE7.Vector3();
+    this.threeRef.object.getWorldDirection(target);
+    return target;
+  }
+  /**
+   * Returns a unit vector pointing from this entity toward the given world
+   * position, or `null` if the entity has no scene presence.
+   *
+   * @param targetPosition - Destination point in world space.
+   */
+  directionTo(targetPosition) {
+    const currentPosition = this.getWorldPosition();
+    if (!currentPosition) {
+      return null;
+    }
+    return targetPosition.clone().sub(currentPosition).normalize();
+  }
+  /**
+   * Returns the world-space distance from this entity to the given position,
+   * or `null` if the entity has no scene presence.
+   *
+   * @param targetPosition - Destination point in world space.
+   */
+  distanceTo(targetPosition) {
+    const currentPosition = this.getWorldPosition();
+    if (!currentPosition) {
+      return null;
+    }
+    return currentPosition.distanceTo(targetPosition);
+  }
+  /**
+   * Linearly interpolates the entity's position toward `targetPosition` and
+   * writes the result back through {@link TransformComponent}. No-op if the
+   * entity has no scene presence.
+   *
+   * @param targetPosition - Destination point in world space.
+   * @param alpha - Interpolation factor in [0, 1]. Multiply by `deltaTime`
+   *   for frame-rate-independent smoothing.
+   */
+  lerpTo(targetPosition, alpha) {
+    if (!this.threeRef) {
+      return;
+    }
+    const currentPosition = this.getWorldPosition();
+    if (!currentPosition) {
+      return;
+    }
+    const newPosition = currentPosition.lerp(targetPosition, alpha);
+    this.transform.setPosition(newPosition);
+  }
+  /**
+   * Spherically interpolates the entity's rotation toward `targetRotation`
+   * and writes the result back through {@link TransformComponent}. No-op if
+   * the entity has no scene presence.
+   *
+   * @param targetRotation - Destination orientation as a quaternion.
+   * @param alpha - Interpolation factor in [0, 1].
+   */
+  slerpTo(targetRotation, alpha) {
+    if (!this.threeRef) {
+      return;
+    }
+    const rotation = new THREE7.Quaternion();
+    this.threeRef.object.getWorldQuaternion(rotation);
+    rotation.slerp(targetRotation, alpha);
+    this.transform.setRotation(rotation);
+  }
+  /**
+   * Rotates the entity to face `targetPosition` in world space and writes the
+   * resulting orientation back through {@link TransformComponent}. No-op if
+   * the entity has no scene presence.
+   *
+   * @param targetPosition - Point in world space to face.
+   */
+  lookAt(targetPosition) {
+    if (!this.threeRef) {
+      return;
+    }
+    const clone = this.threeRef.object.clone();
+    const rotation = new THREE7.Quaternion();
+    clone.lookAt(targetPosition);
+    clone.getWorldQuaternion(rotation);
+    this.transform.setRotation(rotation);
+  }
+  /** Returns every component currently attached to this entity. */
+  getComponents() {
+    return this.world.getEntityById(this.entityId)?.components ?? [];
+  }
+  /**
+   * Returns the entity's component of the given class, or `null` if it has
+   * no such component.
+   *
+   * @typeParam T - Concrete component type.
+   * @param componentClass - Component class constructor to look up.
+   *
+   * @example
+   * ```ts
+   * const mesh = this.getComponent(MeshComponent);
+   * if (mesh) console.log(mesh.geometryRef);
+   * ```
+   */
+  getComponent(componentClass) {
+    return this.world.getComponent(this.entityId, componentClass) ?? null;
+  }
+  /**
+   * Returns the latest {@link WorldEntityView} snapshot for this entity, or
+   * `null` if it was destroyed.
+   */
+  getEntity() {
+    return this.world.getEntityById(this.entityId);
+  }
+  /**
+   * Resolves the entity's parent from the {@link ParentId} component, if any.
+   *
+   * @returns A {@link ParentLookup} with the parent component reference and
+   *   the parent entity view (or `null` if the entity is at the root).
+   */
+  getParent() {
+    const parentIdComponent = this.getComponent(ParentId);
+    const parentEntityId = parentIdComponent?.value ?? null;
+    if (parentEntityId === null) {
+      return {
+        parentIdComponent,
+        parent: null
+      };
+    }
+    return {
+      parentIdComponent,
+      parent: this.world.getEntityById(parentEntityId)
+    };
+  }
+  /**
+   * Returns every direct child entity of this one (entities whose
+   * {@link ParentId} matches `entityId`).
+   */
+  getChildren() {
+    return this.world.getAllEntities().filter((entity) => {
+      const parentIdComponent = entity.components.find(
+        (component) => component instanceof ParentId
+      );
+      return parentIdComponent?.value === this.entityId;
+    });
+  }
+  /**
+   * Called once before the first {@link Behaviour.onUpdate}. Override to
+   * default and validate {@link Behaviour.data}, cache references, or set
+   * initial state.
+   *
+   * @remarks
+   * Also called in editor mode when `executeInEditor` is `true` on the script
+   * entry.
+   */
+  init() {
+  }
+  /**
+   * Called every frame while the script is enabled. Override with the
+   * script's main per-frame logic.
+   *
+   * @remarks
+   * Also called every frame in editor mode when `executeInEditor` is `true`.
+   * Access the Three.js scene with `this.world.getScene()` for editor-only
+   * rendering work such as custom shaders or procedural geometry.
+   */
+  onUpdate() {
+  }
+  /** Called when the editor selects this entity. Optional UX hook. */
+  onSelect() {
+  }
+  /** Called when the editor deselects this entity. Optional UX hook. */
+  onDeselect() {
+  }
+  /**
+   * Called when an image-tracking target this entity depends on becomes
+   * visible. Optional AR hook.
+   *
+   * @param target - The newly-visible target entity view.
+   */
+  onTargetFound(target) {
+  }
+  /**
+   * Called when an image-tracking target this entity depends on is lost.
+   * Optional AR hook.
+   *
+   * @param target - The target entity view that became invisible.
+   */
+  onTargetLost(target) {
+  }
+};
+__name(_Behaviour, "Behaviour");
+/**
+ * Static marker used by `ScriptBehaviourSystem` to detect `Behaviour`
+ * subclasses across bundle-identity splits (esbuild may produce a second
+ * copy of the package when scripts are bundled, breaking `instanceof`).
+ * Inherited by every subclass via the prototype chain.
+ *
+ * @internal
+ */
+_Behaviour.__reluBehaviourClass = true;
+var Behaviour = _Behaviour;
+
+// core/systems/ScriptBehaviourSystem.ts
+function toErrorMessage(error) {
+  const sanitize = /* @__PURE__ */ __name((value) => value.replace(/localasset:\/\/[^/]+\//g, "localasset://").replace(/\/Users\/[^\s)]+/g, "[local path]"), "sanitize");
+  if (error instanceof Error && error.message) {
+    return sanitize(error.message);
+  }
+  if (typeof error === "string" && error) {
+    return sanitize(error);
+  }
+  return "Unknown script error.";
+}
+__name(toErrorMessage, "toErrorMessage");
+function buildInstanceKey(entityId, scriptUrl, className) {
+  return `${entityId}:${scriptUrl}:${className}`;
+}
+__name(buildInstanceKey, "buildInstanceKey");
+function resolveBehaviourCtor(moduleValue, className) {
+  const named = moduleValue[className];
+  const fallback = moduleValue.default;
+  const candidate = typeof named === "function" ? named : typeof fallback === "function" ? fallback : null;
+  if (!candidate) {
+    return null;
+  }
+  if (!(candidate.prototype instanceof Behaviour)) {
+    const isBehaviourSubclass = !!candidate.__reluBehaviourClass;
+    if (!isBehaviourSubclass) {
+      return null;
+    }
+  }
+  return candidate;
+}
+__name(resolveBehaviourCtor, "resolveBehaviourCtor");
+function normalizeScriptData(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+__name(normalizeScriptData, "normalizeScriptData");
+function isPlainObject(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+__name(isPlainObject, "isPlainObject");
+function mergeValueByDefaultShape(defaultValue, currentValue) {
+  if (Array.isArray(defaultValue)) {
+    return Array.isArray(currentValue) ? currentValue : defaultValue;
+  }
+  if (isPlainObject(defaultValue)) {
+    if (!isPlainObject(currentValue)) {
+      return defaultValue;
+    }
+    const next = {};
+    for (const key of Object.keys(defaultValue)) {
+      next[key] = mergeValueByDefaultShape(defaultValue[key], currentValue[key]);
+    }
+    return next;
+  }
+  if (typeof defaultValue === "number") {
+    return typeof currentValue === "number" ? currentValue : defaultValue;
+  }
+  if (typeof defaultValue === "string") {
+    return typeof currentValue === "string" ? currentValue : defaultValue;
+  }
+  if (typeof defaultValue === "boolean") {
+    return typeof currentValue === "boolean" ? currentValue : defaultValue;
+  }
+  if (defaultValue === null) {
+    return currentValue !== void 0 ? currentValue : null;
+  }
+  return typeof currentValue === "undefined" ? defaultValue : currentValue;
+}
+__name(mergeValueByDefaultShape, "mergeValueByDefaultShape");
+function mergeDataByCurrentDefaults(defaults, current) {
+  const next = {};
+  for (const key of Object.keys(defaults)) {
+    next[key] = mergeValueByDefaultShape(defaults[key], current[key]);
+  }
+  return next;
+}
+__name(mergeDataByCurrentDefaults, "mergeDataByCurrentDefaults");
+function isRawEntityInput(value) {
+  if (!isPlainObject(value)) return false;
+  return value.type === "entity";
+}
+__name(isRawEntityInput, "isRawEntityInput");
+function isRawComponentInput(value) {
+  if (!isPlainObject(value)) return false;
+  return value.type === "component";
+}
+__name(isRawComponentInput, "isRawComponentInput");
+function findComponentByKind(components, componentKind) {
+  return components.find(
+    (c) => c.constructor.name === `${componentKind}Component` || c.constructor.name === componentKind
+  ) ?? null;
+}
+__name(findComponentByKind, "findComponentByKind");
+function resolveInputData(world, rawData) {
+  const resolved = { ...rawData };
+  for (const [key, value] of Object.entries(rawData)) {
+    if (isRawEntityInput(value)) {
+      const entityId = value.value;
+      const entityView = typeof entityId === "number" ? world.getEntityById(entityId) : null;
+      resolved[key] = { ...value, value: entityView };
+    } else if (isRawComponentInput(value)) {
+      const ref = value.value;
+      if (isPlainObject(ref) && typeof ref.entityId === "number" && typeof ref.componentKind === "string") {
+        const { entityId: refEntityId, componentKind } = ref;
+        const entityView = world.getEntityById(refEntityId);
+        const component = entityView ? findComponentByKind(entityView.components, componentKind) : null;
+        resolved[key] = { ...value, value: component };
+      }
+    }
+  }
+  return resolved;
+}
+__name(resolveInputData, "resolveInputData");
+function serializeDataForStorage(rawData, behaviourData) {
+  const result = { ...behaviourData };
+  for (const [key, rawValue] of Object.entries(rawData)) {
+    if (isRawEntityInput(rawValue) || isRawComponentInput(rawValue)) {
+      result[key] = rawValue;
+    }
+  }
+  return result;
+}
+__name(serializeDataForStorage, "serializeDataForStorage");
+function normalizeEntry(value, fallbackEntityId) {
+  return {
+    entityId: typeof value?.entityId === "number" ? value.entityId : fallbackEntityId,
+    className: typeof value?.className === "string" ? value.className : "",
+    scriptUrl: typeof value?.scriptUrl === "string" ? value.scriptUrl : "",
+    enabled: typeof value?.enabled === "boolean" ? value.enabled : true,
+    executeInEditor: typeof value?.executeInEditor === "boolean" ? value.executeInEditor : false,
+    data: normalizeScriptData(value?.data),
+    runtimeState: value?.runtimeState === "idle" || value?.runtimeState === "loading" || value?.runtimeState === "ready" || value?.runtimeState === "error" ? value.runtimeState : void 0,
+    runtimeMessage: typeof value?.runtimeMessage === "string" ? value.runtimeMessage : void 0
+  };
+}
+__name(normalizeEntry, "normalizeEntry");
+function readScriptEntries(component, entityId) {
+  if (Array.isArray(component.entries) && component.entries.length > 0) {
+    return component.entries.map((entry) => normalizeEntry(entry, entityId)).filter((entry) => entry.className || entry.scriptUrl);
+  }
+  return [];
+}
+__name(readScriptEntries, "readScriptEntries");
+function writeScriptEntries(component, entries) {
+  const normalized = entries.map((entry) => normalizeEntry(entry, entry.entityId));
+  component.entries = normalized;
+  const active = normalized[0];
+  if (!active) {
+    component.scriptInstance = null;
+  }
+}
+__name(writeScriptEntries, "writeScriptEntries");
+async function defaultModuleLoader(scriptUrl) {
+  return await import(
+    /* webpackIgnore: true */
+    scriptUrl
+  );
+}
+__name(defaultModuleLoader, "defaultModuleLoader");
+var _ScriptBehaviourSystem = class _ScriptBehaviourSystem {
+  constructor(moduleLoader, selectionContext) {
+    this.instances = /* @__PURE__ */ new Map();
+    this.loading = /* @__PURE__ */ new Map();
+    this.selectedEntityId = null;
+    // undefined = nothing queued; null = queued "deselect all"; number = queued entity
+    this.pendingEntityId = void 0;
+    this.pointerDownPos = null;
+    this.onPointerDown = /* @__PURE__ */ __name((event) => {
+      this.pointerDownPos = { x: event.clientX, y: event.clientY };
+    }, "onPointerDown");
+    this.onPointerUp = /* @__PURE__ */ __name((event) => {
+      if (!this.pointerDownPos) return;
+      const dx = event.clientX - this.pointerDownPos.x;
+      const dy = event.clientY - this.pointerDownPos.y;
+      this.pointerDownPos = null;
+      if (Math.sqrt(dx * dx + dy * dy) > _ScriptBehaviourSystem.CLICK_THRESHOLD) return;
+      this.queueRaycast(event.clientX, event.clientY);
+    }, "onPointerUp");
+    this.moduleLoader = moduleLoader ?? defaultModuleLoader;
+    this.selectionCtx = selectionContext ?? null;
+    this.raycaster = new THREE7.Raycaster();
+    this.ndcPointer = new THREE7.Vector2();
+    if (this.selectionCtx) {
+      this.selectionCtx.domElement.addEventListener("pointerdown", this.onPointerDown);
+      this.selectionCtx.domElement.addEventListener("pointerup", this.onPointerUp);
+    }
+  }
+  // ── Raycast selection helpers ──────────────────────────────────────────────
+  /** Walk up the object hierarchy to find the nearest userData.entityId. */
+  resolveEntityId(object) {
+    let current = object;
+    while (current) {
+      const id = current.userData?.entityId;
+      if (typeof id === "number") return id;
+      current = current.parent;
+    }
+    return null;
+  }
+  /** Convert client (screen) coordinates to normalised device coordinates. */
+  toNdc(clientX, clientY) {
+    if (!this.selectionCtx) return;
+    const rect = this.selectionCtx.domElement.getBoundingClientRect();
+    this.ndcPointer.x = (clientX - rect.left) / rect.width * 2 - 1;
+    this.ndcPointer.y = -((clientY - rect.top) / rect.height) * 2 + 1;
+  }
+  /** Fire raycast and queue the result to be dispatched in the next update(). */
+  queueRaycast(clientX, clientY) {
+    if (!this.selectionCtx) return;
+    this.toNdc(clientX, clientY);
+    this.raycaster.setFromCamera(this.ndcPointer, this.selectionCtx.camera);
+    const hits = this.raycaster.intersectObjects(this.selectionCtx.scene.children, true);
+    for (const hit of hits) {
+      if (hit.object.userData?.ecsPreviewHidden) continue;
+      const entityId = this.resolveEntityId(hit.object);
+      if (entityId !== null) {
+        this.pendingEntityId = entityId;
+        return;
+      }
+    }
+    this.pendingEntityId = null;
+  }
+  /**
+   * Apply a queued selection change.
+   * Calls onDeselect() on all behaviours of the previous entity and
+   * onSelect() on all behaviours of the newly selected entity.
+   */
+  applySelection(nextEntityId) {
+    if (nextEntityId === this.selectedEntityId) return;
+    const prevEntityId = this.selectedEntityId;
+    this.selectedEntityId = nextEntityId;
+    if (prevEntityId !== null) {
+      for (const record of this.instances.values()) {
+        if (record.entityId === prevEntityId) {
+          try {
+            record.behaviour.onDeselect();
+          } catch {
+          }
+        }
+      }
+    }
+    if (nextEntityId !== null) {
+      for (const record of this.instances.values()) {
+        if (record.entityId === nextEntityId) {
+          try {
+            record.behaviour.onSelect();
+          } catch {
+          }
+        }
+      }
+    }
+  }
+  // ── ECS lifecycle ──────────────────────────────────────────────────────────
+  update(world, deltaTime) {
+    if (this.pendingEntityId !== void 0) {
+      const next = this.pendingEntityId;
+      this.pendingEntityId = void 0;
+      this.applySelection(next);
+    }
+    const active = /* @__PURE__ */ new Map();
+    const entityIds = world.query(ScriptComponent);
+    for (const entityId of entityIds) {
+      const scriptComponent = world.getComponent(entityId, ScriptComponent);
+      if (!scriptComponent) {
+        continue;
+      }
+      const entries = readScriptEntries(scriptComponent, entityId);
+      if (entries.length === 0) {
+        scriptComponent.scriptInstance = null;
+        continue;
+      }
+      const nextEntries = [...entries];
+      let hasEnabledScript = false;
+      for (let entryIndex = 0; entryIndex < nextEntries.length; entryIndex += 1) {
+        const entry = nextEntries[entryIndex];
+        const skipInEditor = world.isEditorMode() && !entry.executeInEditor;
+        if (!entry.enabled || !entry.scriptUrl || skipInEditor) {
+          nextEntries[entryIndex] = {
+            ...entry,
+            runtimeState: skipInEditor ? "idle" : "idle",
+            runtimeMessage: void 0
+          };
+          continue;
+        }
+        hasEnabledScript = true;
+        const key = buildInstanceKey(entityId, entry.scriptUrl, entry.className);
+        active.set(key, {
+          entityId,
+          scriptComponent,
+          entryIndex,
+          scriptEntry: entry
+        });
+      }
+      writeScriptEntries(scriptComponent, nextEntries);
+      if (!hasEnabledScript) {
+        scriptComponent.scriptInstance = null;
+      }
+    }
+    for (const [key, record] of this.instances.entries()) {
+      const script = active.get(key);
+      if (!script) {
+        const liveComponent = world.getComponent(record.entityId, ScriptComponent);
+        if (liveComponent) {
+          if (record.entryIndex === 0) {
+            liveComponent.scriptInstance = null;
+          }
+          liveComponent.scriptInstances.delete(record.entryIndex);
+        }
+        record.behaviour.dispose?.(world);
+        this.instances.delete(key);
+        continue;
+      }
+      const entries = readScriptEntries(script.scriptComponent, script.entityId);
+      const liveEntry = entries[script.entryIndex];
+      if (!liveEntry) {
+        record.behaviour.dispose?.(world);
+        this.instances.delete(key);
+        continue;
+      }
+      if (!world.isEntityVisible(record.entityId)) {
+        continue;
+      }
+      try {
+        script.scriptComponent.scriptInstance = script.entryIndex === 0 ? record.behaviour : script.scriptComponent.scriptInstance;
+        script.scriptComponent.scriptInstances.set(script.entryIndex, record.behaviour);
+        entries[script.entryIndex] = {
+          ...liveEntry,
+          data: serializeDataForStorage(record.rawData, normalizeScriptData(record.behaviour.data))
+        };
+        record.behaviour.update(world, deltaTime);
+        entries[script.entryIndex] = {
+          ...entries[script.entryIndex],
+          data: serializeDataForStorage(record.rawData, normalizeScriptData(record.behaviour.data)),
+          runtimeState: "ready",
+          runtimeMessage: void 0
+        };
+        writeScriptEntries(script.scriptComponent, entries);
+      } catch (error) {
+        entries[script.entryIndex] = {
+          ...entries[script.entryIndex],
+          runtimeState: "error",
+          runtimeMessage: toErrorMessage(error)
+        };
+        writeScriptEntries(script.scriptComponent, entries);
+        if (script.entryIndex === 0) {
+          script.scriptComponent.scriptInstance = null;
+        }
+        record.behaviour.dispose?.(world);
+        this.instances.delete(key);
+      }
+    }
+    if (this.selectedEntityId !== null) {
+      let stillActive = false;
+      for (const record of this.instances.values()) {
+        if (record.entityId === this.selectedEntityId) {
+          stillActive = true;
+          break;
+        }
+      }
+      if (!stillActive) {
+        this.selectedEntityId = null;
+      }
+    }
+    for (const [key, script] of active.entries()) {
+      if (this.instances.has(key) || this.loading.has(key)) {
+        continue;
+      }
+      const entries = readScriptEntries(script.scriptComponent, script.entityId);
+      const targetEntry = entries[script.entryIndex];
+      if (targetEntry) {
+        entries[script.entryIndex] = {
+          ...targetEntry,
+          runtimeState: "loading",
+          runtimeMessage: void 0
+        };
+        writeScriptEntries(script.scriptComponent, entries);
+      }
+      const promise = this.loadBehaviour(world, script).catch((error) => {
+        const liveEntries = readScriptEntries(script.scriptComponent, script.entityId);
+        const liveEntry = liveEntries[script.entryIndex];
+        if (liveEntry) {
+          liveEntries[script.entryIndex] = {
+            ...liveEntry,
+            runtimeState: "error",
+            runtimeMessage: "Failed to load script."
+          };
+          writeScriptEntries(script.scriptComponent, liveEntries);
+        }
+        if (script.entryIndex === 0) {
+          script.scriptComponent.scriptInstance = null;
+        }
+        console.error(
+          `[ScriptBehaviourSystem] Failed loading script ${script.scriptEntry.className}`,
+          error
+        );
+      }).finally(() => {
+        this.loading.delete(key);
+      });
+      this.loading.set(key, promise);
+    }
+    for (const key of this.loading.keys()) {
+      if (active.has(key)) {
+        continue;
+      }
+      this.loading.delete(key);
+    }
+  }
+  dispose(world) {
+    if (this.selectionCtx) {
+      this.selectionCtx.domElement.removeEventListener("pointerdown", this.onPointerDown);
+      this.selectionCtx.domElement.removeEventListener("pointerup", this.onPointerUp);
+    }
+    for (const record of this.instances.values()) {
+      const liveComponent = world.getComponent(record.entityId, ScriptComponent);
+      if (liveComponent) {
+        if (record.entryIndex === 0) {
+          liveComponent.scriptInstance = null;
+        }
+        liveComponent.scriptInstances.delete(record.entryIndex);
+      }
+      record.behaviour.dispose?.(world);
+    }
+    this.instances.clear();
+    this.loading.clear();
+  }
+  async loadBehaviour(world, script) {
+    const { entityId, scriptComponent, entryIndex, scriptEntry } = script;
+    const key = buildInstanceKey(
+      entityId,
+      scriptEntry.scriptUrl,
+      scriptEntry.className
+    );
+    const moduleValue = await this.moduleLoader(scriptEntry.scriptUrl);
+    const ctor = resolveBehaviourCtor(moduleValue, scriptEntry.className);
+    if (!ctor) {
+      throw new Error(
+        `Missing Behaviour export '${scriptEntry.className}' in ${scriptEntry.scriptUrl}`
+      );
+    }
+    if (!world.hasEntity(entityId)) {
+      return;
+    }
+    const liveComponent = world.getComponent(entityId, ScriptComponent);
+    if (!liveComponent) {
+      return;
+    }
+    const liveEntries = readScriptEntries(liveComponent, entityId);
+    const liveEntry = liveEntries[entryIndex];
+    if (!liveEntry || !liveEntry.enabled || !liveEntry.scriptUrl || liveEntry.scriptUrl !== scriptEntry.scriptUrl || liveEntry.className !== scriptEntry.className) {
+      return;
+    }
+    const currentData = normalizeScriptData(liveEntry.data);
+    let behaviour;
+    try {
+      behaviour = new ctor(
+        world,
+        entityId,
+        void 0
+      );
+    } catch {
+      behaviour = new ctor(world, entityId, currentData);
+    }
+    const defaults = normalizeScriptData(behaviour.data);
+    const mergedData = mergeDataByCurrentDefaults(defaults, currentData);
+    const resolvedData = resolveInputData(world, mergedData);
+    behaviour.data = resolvedData;
+    if (!world.isEditorMode() || liveEntry.executeInEditor === true) {
+      behaviour.init();
+    }
+    liveEntries[entryIndex] = {
+      ...liveEntry,
+      data: mergedData,
+      runtimeState: "ready",
+      runtimeMessage: void 0
+    };
+    writeScriptEntries(liveComponent, liveEntries);
+    if (entryIndex === 0) {
+      liveComponent.scriptInstance = behaviour;
+    }
+    liveComponent.scriptInstances.set(entryIndex, behaviour);
+    this.instances.set(key, {
+      entityId,
+      scriptUrl: scriptEntry.scriptUrl,
+      className: scriptEntry.className,
+      entryIndex,
+      behaviour,
+      rawData: mergedData
+    });
+  }
+};
+__name(_ScriptBehaviourSystem, "ScriptBehaviourSystem");
+_ScriptBehaviourSystem.CLICK_THRESHOLD = 6;
+var ScriptBehaviourSystem = _ScriptBehaviourSystem;
+
+// core/systems/TransformSyncSystem.ts
+var _TransformSyncSystem = class _TransformSyncSystem {
+  update(world) {
+    const entities = world.query(TransformComponent, Object3DRef);
+    for (const entityId of entities) {
+      const transform = world.getComponent(entityId, TransformComponent);
+      const object = world.getComponent(entityId, Object3DRef)?.object;
+      if (!transform || !object) {
+        continue;
+      }
+      applyTransform(object, transform);
+      object.updateMatrixWorld(true);
+    }
+  }
+};
+__name(_TransformSyncSystem, "TransformSyncSystem");
+var TransformSyncSystem = _TransformSyncSystem;
+function snapshotOptions(opts) {
+  return {
+    loop: opts.loop,
+    pitch: opts.pitch,
+    volume: opts.volume,
+    refDistance: opts.refDistance,
+    distanceModel: opts.distanceModel,
+    rolloffFactor: opts.rolloffFactor
+  };
+}
+__name(snapshotOptions, "snapshotOptions");
+var _AudioSystem = class _AudioSystem {
+  constructor({ isEditor = false } = {}) {
+    /** THREE.js `isPlaying` state captured at the end of the previous frame. */
+    this.prevPlayingState = /* @__PURE__ */ new Map();
+    /** Snapshot of options applied in the previous frame, for change detection. */
+    this.prevOptions = /* @__PURE__ */ new Map();
+    this.isEditor = isEditor;
+  }
+  update(world, _deltaTime) {
+    if (this.isEditor) return;
+    const entities = world.query(AudioComponent);
+    const liveEntityIds = new Set(entities);
+    for (const entityId of entities) {
+      const component = world.getComponent(entityId, AudioComponent);
+      if (!component?.audio) continue;
+      const sound = component.audio;
+      if (!world.isEntityVisible(entityId)) {
+        if (sound.isPlaying) sound.stop();
+        continue;
+      }
+      this._syncOptions(entityId, component, sound);
+      const prevWasPlaying = this.prevPlayingState.get(entityId) ?? false;
+      if (prevWasPlaying && !sound.isPlaying && component.isPlaying && !component.isPaused) {
+        component.isPlaying = false;
+      }
+      if (component.isPlaying && !sound.isPlaying) {
+        if (sound.buffer) {
+          sound.play();
+        }
+      } else if (!component.isPlaying && sound.isPlaying) {
+        if (component.isPaused) {
+          sound.pause();
+        } else {
+          sound.stop();
+        }
+      }
+      this.prevPlayingState.set(entityId, sound.isPlaying);
+    }
+    for (const entityId of this.prevPlayingState.keys()) {
+      if (!liveEntityIds.has(entityId)) {
+        this.prevPlayingState.delete(entityId);
+        this.prevOptions.delete(entityId);
+      }
+    }
+  }
+  /** Apply any changed options from the component to the THREE.js audio node. */
+  _syncOptions(entityId, component, sound) {
+    const opts = component.options;
+    const prev = this.prevOptions.get(entityId);
+    if (!prev || prev.loop !== opts.loop) {
+      sound.setLoop(opts.loop);
+    }
+    if (!prev || prev.pitch !== opts.pitch) {
+      sound.setPlaybackRate(opts.pitch);
+    }
+    if (!prev || prev.volume !== opts.volume) {
+      sound.setVolume(opts.volume);
+    }
+    if (opts.positional && sound instanceof THREE7.PositionalAudio) {
+      if (!prev || prev.refDistance !== opts.refDistance) {
+        sound.setRefDistance(opts.refDistance);
+      }
+      if (!prev || prev.distanceModel !== opts.distanceModel) {
+        sound.setDistanceModel(opts.distanceModel);
+      }
+      if (!prev || prev.rolloffFactor !== opts.rolloffFactor) {
+        sound.setRolloffFactor(opts.rolloffFactor);
+      }
+    }
+    this.prevOptions.set(entityId, snapshotOptions(opts));
+  }
+  dispose(_world) {
+    this.prevPlayingState.clear();
+    this.prevOptions.clear();
+  }
+};
+__name(_AudioSystem, "AudioSystem");
+var AudioSystem = _AudioSystem;
+function snapshotOptions2(opts) {
+  return {
+    loop: opts.loop,
+    volume: opts.volume,
+    width: opts.width,
+    height: opts.height,
+    backgroundColor: opts.backgroundColor,
+    similarity: opts.similarity,
+    smoothness: opts.smoothness,
+    spill: opts.spill,
+    positional: opts.positional,
+    refDistance: opts.refDistance,
+    distanceModel: opts.distanceModel,
+    rolloffFactor: opts.rolloffFactor
+  };
+}
+__name(snapshotOptions2, "snapshotOptions");
+var _VideoSystem = class _VideoSystem {
+  constructor({ isEditor = false } = {}) {
+    /** Playback intent captured at the end of the previous frame. */
+    this.prevIntent = /* @__PURE__ */ new Map();
+    /** Snapshot of options applied in the previous frame, for change detection. */
+    this.prevOptions = /* @__PURE__ */ new Map();
+    this.isEditor = isEditor;
+  }
+  update(world, _deltaTime) {
+    if (this.isEditor) return;
+    const entities = world.query(VideoComponent);
+    const liveEntityIds = new Set(entities);
+    for (const entityId of entities) {
+      const component = world.getComponent(entityId, VideoComponent);
+      if (!component?.videoElement) continue;
+      const video = component.videoElement;
+      if (!world.isEntityVisible(entityId)) {
+        if (!video.paused) video.pause();
+        continue;
+      }
+      this._syncOptions(entityId, component, video);
+      const prev = this.prevIntent.get(entityId) ?? { isPlaying: false, isPaused: false };
+      if (prev.isPlaying && video.paused && !video.seeking && component.isPlaying && !component.isPaused) {
+        component.isPlaying = false;
+      }
+      const isStoppedNow = !component.isPlaying && !component.isPaused;
+      const wasStoppedPrev = !prev.isPlaying && !prev.isPaused;
+      const justStopped = !wasStoppedPrev && isStoppedNow;
+      if (component.isPlaying) {
+        if (video.paused) {
+          video.play().catch(() => {
+          });
+        }
+      } else if (component.isPaused) {
+        if (!video.paused) {
+          video.pause();
+        }
+      } else {
+        if (!video.paused) {
+          video.pause();
+        }
+        if (justStopped) {
+          video.currentTime = 0;
+        }
+      }
+      this.prevIntent.set(entityId, {
+        isPlaying: component.isPlaying,
+        isPaused: component.isPaused
+      });
+    }
+    for (const entityId of this.prevIntent.keys()) {
+      if (!liveEntityIds.has(entityId)) {
+        this.prevIntent.delete(entityId);
+        this.prevOptions.delete(entityId);
+      }
+    }
+  }
+  /** Apply any changed options from the component to the video element and mesh. */
+  _syncOptions(entityId, component, video) {
+    const opts = component.options;
+    const prev = this.prevOptions.get(entityId);
+    if (!prev || prev.loop !== opts.loop) {
+      video.loop = opts.loop;
+    }
+    if (!prev || prev.volume !== opts.volume) {
+      if (component.audioNode) {
+        component.audioNode.setVolume(Math.max(0, Math.min(1, opts.volume)));
+      } else {
+        video.volume = Math.max(0, Math.min(1, opts.volume));
+      }
+    }
+    if ((!prev || prev.width !== opts.width || prev.height !== opts.height) && component.object) {
+      component.object.scale.set(opts.width, opts.height, 1);
+    }
+    const material = component.material;
+    if (material instanceof THREE7.ShaderMaterial) {
+      if (!prev || prev.backgroundColor !== opts.backgroundColor) {
+        material.uniforms.keyColor.value.set(opts.backgroundColor);
+      }
+      if (!prev || prev.similarity !== opts.similarity) {
+        material.uniforms.similarity.value = opts.similarity;
+      }
+      if (!prev || prev.smoothness !== opts.smoothness) {
+        material.uniforms.smoothness.value = opts.smoothness;
+      }
+      if (!prev || prev.spill !== opts.spill) {
+        material.uniforms.spill.value = opts.spill;
+      }
+    }
+    if (opts.positional && component.audioNode instanceof THREE7.PositionalAudio) {
+      const posAudio = component.audioNode;
+      if (!prev || prev.refDistance !== opts.refDistance) {
+        posAudio.setRefDistance(opts.refDistance);
+      }
+      if (!prev || prev.distanceModel !== opts.distanceModel) {
+        posAudio.setDistanceModel(opts.distanceModel);
+      }
+      if (!prev || prev.rolloffFactor !== opts.rolloffFactor) {
+        posAudio.setRolloffFactor(opts.rolloffFactor);
+      }
+    }
+    this.prevOptions.set(entityId, snapshotOptions2(opts));
+  }
+  dispose(_world) {
+    this.prevIntent.clear();
+    this.prevOptions.clear();
+  }
+};
+__name(_VideoSystem, "VideoSystem");
+var VideoSystem = _VideoSystem;
+
+export { AnimationSystem, AudioSystem, Behaviour, CameraSyncSystem, EnvironmentSyncSystem, InputSystem, KeyboardKeys, LightSyncSystem, MaterialSyncSystem, MeshGeometrySystem, ObjectVisibilitySystem, PhysicsSyncSystem, PostprocessingSyncSystem, RenderSystem, ScriptBehaviourSystem, TransformSyncSystem, VideoSystem };
+//# sourceMappingURL=chunk-P2YDX5DB.js.map
+//# sourceMappingURL=chunk-P2YDX5DB.js.map