@relu-interactives/spatial-ecs 0.5.2 → 0.8.0

package/dist/{chunk-DF5SSRN6.js → chunk-JIJQFW6P.js}

@@ -1,36 +1,15 @@
-import { resolveDracoDecoderPath, applyTransform, SHARED_MODEL_RESOURCE_FLAG } from './chunk-WJD2VKEH.js';
-import { AnimationComponent, ModelComponent, CameraComponent, Object3DRef, Environment, Postprocessing, TransformComponent, PhysicsComponent, setPhysicsLiveRef, LightComponent, MaterialComponent, DEFAULT_MESH_GEOMETRY_PARAMETERS, MeshGeometryComponent, InstancedMeshComponent, ParentId, ScriptComponent, ScriptObjectComponent, XRRigComponent, VRTeleportAreaComponent, XRInteractableComponent, createAttachPoint, XRHandPoseComponent, createHandPoseEntry, XRAnchorComponent, UIPanelComponent, UITextComponent, UIButtonComponent, UIToggleComponent, UISliderComponent, XRInteractorComponent, XRInteractorSideComponent, InstanceSlotComponent, Name, ImageComponent, SpriteComponent, VideoComponent, AudioComponent, ImageTarget, Selectable, PrefabNode, PrefabInstance, XREnvironmentComponent, handPoseDefinitionFor, getHandPosePreset } from './chunk-BUEKOSR5.js';
-import { __name } from './chunk-OY7ZODZP.js';
+import { getRendererKindOf, readWorldRenderBackend, readWorldRendererKind } from './chunk-OHCNPPMX.js';
+import { resolveScriptCtor, Behaviour, normalizeScriptData, defaultModuleLoader, reportScriptError, serializeDataForStorage, toErrorMessage, readScriptPhase, withScriptPhase, mergeDataByCurrentDefaults, resolveInputData, resolvePrefabAssetUrl, reportBehaviourHookError } from './chunk-U727NTWQ.js';
+import { createGLTFLoader, SHARED_MODEL_RESOURCE_FLAG, applyTransform, findModelBone } from './chunk-G4XJ53LS.js';
+import { AnimationComponent, ModelComponent, CameraComponent, Object3DRef, normalizeEnvironmentLighting, Environment, Postprocessing, TransformComponent, PhysicsComponent, setPhysicsLiveRef, LightComponent, MaterialComponent, DEFAULT_MESH_GEOMETRY_PARAMETERS, MeshGeometryComponent, InstancedMeshComponent, ScriptComponent, ScriptObjectComponent, AudioComponent, VideoComponent, XRInteractableComponent, XRRigComponent, VRTeleportAreaComponent, ParentId, XREnvironmentComponent, UIButtonComponent, UIToggleComponent, UISliderComponent, Name, UIPanelComponent, UITextComponent, XRAnchorComponent, IKComponent, XRInteractorComponent, XRInteractorSideComponent, handPoseDefinitionFor, getHandPosePreset, XRHandPoseComponent } from './chunk-NNDUOQ7O.js';
+import { __name } from './chunk-XE4OXN2W.js';
 import * as THREE19 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';
 import { XRControllerModelFactory } from 'three/examples/jsm/webxr/XRControllerModelFactory.js';
 import { XRHandModelFactory } from 'three/examples/jsm/webxr/XRHandModelFactory.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;
+  return createGLTFLoader();
 }
 __name(createClipSourceLoader, "createClipSourceLoader");
 function normalizeDeltaTime(deltaTime) {
@@ -579,6 +558,88 @@ var _ObjectVisibilitySystem = class _ObjectVisibilitySystem {
 };
 __name(_ObjectVisibilitySystem, "ObjectVisibilitySystem");
 var ObjectVisibilitySystem = _ObjectVisibilitySystem;
+function getUrlExtension(url) {
+  const path = url.split(/[?#]/)[0] ?? "";
+  const lastSegment = path.split("/").pop() ?? "";
+  const dot = lastSegment.lastIndexOf(".");
+  return dot >= 0 ? lastSegment.slice(dot + 1).toLowerCase() : "";
+}
+__name(getUrlExtension, "getUrlExtension");
+async function loadEquirectTexture(url) {
+  const extension = getUrlExtension(url);
+  let texture;
+  if (extension === "hdr") {
+    const { HDRLoader } = await import('three/examples/jsm/loaders/HDRLoader.js');
+    texture = await new HDRLoader().loadAsync(url);
+  } else if (extension === "exr") {
+    const { EXRLoader } = await import('three/examples/jsm/loaders/EXRLoader.js');
+    texture = await new EXRLoader().loadAsync(url);
+  } else {
+    texture = await new THREE19.TextureLoader().loadAsync(url);
+    texture.colorSpace = THREE19.SRGBColorSpace;
+  }
+  texture.mapping = THREE19.EquirectangularReflectionMapping;
+  texture.needsUpdate = true;
+  return texture;
+}
+__name(loadEquirectTexture, "loadEquirectTexture");
+var rendererStates = /* @__PURE__ */ new WeakMap();
+function toThreeToneMapping(mode) {
+  switch (mode) {
+    case "aces":
+      return THREE19.ACESFilmicToneMapping;
+    case "agx":
+      return THREE19.AgXToneMapping;
+    case "neutral":
+      return THREE19.NeutralToneMapping;
+    default:
+      return THREE19.NoToneMapping;
+  }
+}
+__name(toThreeToneMapping, "toThreeToneMapping");
+function resolveToneMapping(environment, postprocessing) {
+  const environmentMode = environment && environment.mode !== "none" ? environment.mode : null;
+  const mode = environmentMode ?? (postprocessing ? "aces" : "none");
+  const exposure = postprocessing ? postprocessing.exposure : environment?.exposure ?? 1;
+  return { mode, exposure };
+}
+__name(resolveToneMapping, "resolveToneMapping");
+function setRendererToneMappingSource(renderer, source, request) {
+  if (!renderer || typeof renderer !== "object") {
+    return;
+  }
+  const target = renderer;
+  let state = rendererStates.get(renderer);
+  if (!state) {
+    if (request === null) return;
+    state = {
+      baseline: {
+        toneMapping: target.toneMapping ?? THREE19.NoToneMapping,
+        exposure: typeof target.toneMappingExposure === "number" ? target.toneMappingExposure : 1
+      },
+      environment: null,
+      postprocessing: null
+    };
+    rendererStates.set(renderer, state);
+  }
+  if (source === "environment") {
+    state.environment = request;
+  } else {
+    state.postprocessing = request;
+  }
+  if (!state.environment && !state.postprocessing) {
+    target.toneMapping = state.baseline.toneMapping;
+    target.toneMappingExposure = state.baseline.exposure;
+    rendererStates.delete(renderer);
+    return;
+  }
+  const resolved = resolveToneMapping(state.environment, state.postprocessing);
+  target.toneMapping = toThreeToneMapping(resolved.mode);
+  target.toneMappingExposure = resolved.exposure;
+}
+__name(setRendererToneMappingSource, "setRendererToneMappingSource");
+
+// core/systems/EnvironmentSyncSystem.ts
 var MIN_FOG_DELTA = 1e-3;
 var MIN_DENSITY = 0;
 function createGradientTexture(effect, colors) {
@@ -627,14 +688,48 @@ function createGradientTexture(effect, colors) {
   return texture;
 }
 __name(createGradientTexture, "createGradientTexture");
+function readRenderer(world) {
+  const getRenderer = world.getRenderer;
+  if (typeof getRenderer !== "function") return null;
+  try {
+    return getRenderer.call(world) ?? null;
+  } catch {
+    return null;
+  }
+}
+__name(readRenderer, "readRenderer");
 var _EnvironmentSyncSystem = class _EnvironmentSyncSystem {
   constructor(scene) {
     this.textureLoader = new THREE19.TextureLoader();
-    this.signature = null;
+    /** `true` once an Environment entity has been seen (drives the reset path). */
+    this.hasEnvironment = false;
+    this.skyboxSignature = null;
+    this.fogSignature = null;
+    this.lightingSignature = null;
     this.activeTexture = null;
+    /** Load key (`url`, or `equirect|url`) of the current/pending image skybox. */
     this.pendingImageUrl = null;
+    /** What the skybox wants as the background, before passthrough/env overrides. */
+    this.skyboxBackground = null;
     /** Whether the skybox is currently withheld because passthrough is on. */
     this.passthroughSuppressed = false;
+    // ── Image-based lighting ────────────────────────────────────────────────
+    this.renderer = null;
+    this.lighting = null;
+    /** URL of the environment map currently loaded or loading. */
+    this.envUrl = null;
+    /** Incremented per env-map load; a load whose token is stale is discarded. */
+    this.envLoadToken = 0;
+    /** Equirect source texture of the current environment map. */
+    this.envSource = null;
+    /**
+     * PMREM render target built from {@link envSource} (WebGL only; on WebGPU
+     * the renderer prefilters `scene.environment` itself and this stays null).
+     */
+    this.envTarget = null;
+    this.sceneLightingBaseline = null;
+    this.sceneBackgroundBaseline = null;
+    this.disposed = false;
     this.scene = scene;
   }
   disposeActiveTexture() {
@@ -643,18 +738,53 @@ var _EnvironmentSyncSystem = class _EnvironmentSyncSystem {
       this.activeTexture = null;
     }
   }
-  applySkybox(component) {
-    const skybox = component.values.skybox;
+  /** Write the background the current state calls for. */
+  commitBackground() {
+    if (this.passthroughSuppressed) {
+      this.scene.background = null;
+      return;
+    }
+    const lighting = this.lighting;
+    if (lighting?.useAsBackground && this.envSource) {
+      if (!this.sceneBackgroundBaseline) {
+        this.sceneBackgroundBaseline = {
+          backgroundBlurriness: this.scene.backgroundBlurriness,
+          backgroundIntensity: this.scene.backgroundIntensity,
+          backgroundRotationY: this.scene.backgroundRotation.y
+        };
+      }
+      this.scene.background = this.envSource;
+      this.scene.backgroundBlurriness = lighting.backgroundBlurriness;
+      this.scene.backgroundIntensity = lighting.backgroundIntensity;
+      this.scene.backgroundRotation.y = lighting.envRotationY;
+      return;
+    }
+    this.restoreBackgroundBaseline();
+    this.scene.background = this.skyboxBackground;
+  }
+  restoreBackgroundBaseline() {
+    const baseline = this.sceneBackgroundBaseline;
+    if (!baseline) return;
+    this.scene.backgroundBlurriness = baseline.backgroundBlurriness;
+    this.scene.backgroundIntensity = baseline.backgroundIntensity;
+    this.scene.backgroundRotation.y = baseline.backgroundRotationY;
+    this.sceneBackgroundBaseline = null;
+  }
+  setSkyboxBackground(value) {
+    this.skyboxBackground = value;
+    this.commitBackground();
+  }
+  applySkybox(skybox) {
     if (skybox.type === "none") {
       this.disposeActiveTexture();
       this.pendingImageUrl = null;
-      this.scene.background = null;
+      this.setSkyboxBackground(null);
       return;
     }
     if (skybox.type === "color") {
       this.disposeActiveTexture();
       this.pendingImageUrl = null;
-      this.scene.background = new THREE19.Color(skybox.color || "#1e1e1e");
+      this.setSkyboxBackground(new THREE19.Color(skybox.color || "#1e1e1e"));
       return;
     }
     if (skybox.type === "gradient") {
@@ -665,44 +795,54 @@ var _EnvironmentSyncSystem = class _EnvironmentSyncSystem {
         skybox.gradient.colors
       );
       this.activeTexture = texture;
-      this.scene.background = texture;
+      this.setSkyboxBackground(texture);
       return;
     }
     const imageUrl = skybox.imageUrl?.trim() ?? "";
     if (!imageUrl) {
       this.disposeActiveTexture();
       this.pendingImageUrl = null;
-      this.scene.background = null;
+      this.setSkyboxBackground(null);
       return;
     }
-    if (this.pendingImageUrl === imageUrl && this.activeTexture) {
-      this.scene.background = this.activeTexture;
+    const equirect = skybox.imageProjection === "equirect";
+    const loadKey = equirect ? `equirect|${imageUrl}` : imageUrl;
+    if (this.pendingImageUrl === loadKey && this.activeTexture) {
+      this.setSkyboxBackground(this.activeTexture);
       return;
     }
     this.disposeActiveTexture();
-    this.pendingImageUrl = imageUrl;
-    this.textureLoader.load(
-      imageUrl,
-      (texture) => {
-        if (this.pendingImageUrl !== imageUrl) {
-          texture.dispose();
-          return;
-        }
+    this.pendingImageUrl = loadKey;
+    const onLoaded = /* @__PURE__ */ __name((texture) => {
+      if (this.pendingImageUrl !== loadKey) {
+        texture.dispose();
+        return;
+      }
+      if (!equirect) {
         texture.colorSpace = THREE19.SRGBColorSpace;
-        this.activeTexture = texture;
-        this.scene.background = texture;
-      },
-      void 0,
-      () => {
-        if (this.pendingImageUrl === imageUrl) {
-          this.pendingImageUrl = null;
-          this.scene.background = null;
-        }
       }
-    );
+      this.activeTexture = texture;
+      this.setSkyboxBackground(texture);
+    }, "onLoaded");
+    const onFailed = /* @__PURE__ */ __name(() => {
+      if (this.pendingImageUrl === loadKey) {
+        this.pendingImageUrl = null;
+        this.setSkyboxBackground(null);
+      }
+    }, "onFailed");
+    if (equirect) {
+      loadEquirectTexture(imageUrl).then(onLoaded, (error) => {
+        console.error(
+          `[EnvironmentSyncSystem] Failed to load skybox image ${imageUrl}`,
+          error
+        );
+        onFailed();
+      });
+      return;
+    }
+    this.textureLoader.load(imageUrl, onLoaded, void 0, onFailed);
   }
-  applyFog(component) {
-    const fog = component.values.fog;
+  applyFog(fog) {
     if (fog.type === "none") {
       this.scene.fog = null;
       return;
@@ -718,27 +858,167 @@ var _EnvironmentSyncSystem = class _EnvironmentSyncSystem {
     const density = Number.isFinite(fog.exponential.density) ? Math.max(MIN_DENSITY, fog.exponential.density) : 2e-3;
     this.scene.fog = new THREE19.FogExp2(fogColor, density);
   }
-  update(world) {
-    const passthrough = world.isXrPassthrough();
-    if (passthrough !== this.passthroughSuppressed) {
-      this.passthroughSuppressed = passthrough;
-      if (passthrough) {
+  // ── Image-based lighting ────────────────────────────────────────────────
+  disposeEnvResources() {
+    if (this.envTarget) {
+      this.envTarget.dispose();
+      this.envTarget = null;
+    }
+    if (this.envSource) {
+      this.envSource.dispose();
+      this.envSource = null;
+    }
+  }
+  /** Drop the environment map (any in-flight load is abandoned). */
+  clearEnvMap() {
+    this.envLoadToken += 1;
+    this.envUrl = null;
+    const owned = this.envTarget?.texture ?? this.envSource;
+    if (owned && this.scene.environment === owned) {
+      this.scene.environment = this.sceneLightingBaseline?.environment ?? null;
+    }
+    this.disposeEnvResources();
+  }
+  /**
+   * Undo everything the lighting block wrote to the scene and renderer.
+   * `commit` re-applies the background afterwards (off during teardown, which
+   * must not touch the background).
+   */
+  clearLighting(commit = true) {
+    this.clearEnvMap();
+    const baseline = this.sceneLightingBaseline;
+    if (baseline) {
+      this.scene.environment = baseline.environment;
+      this.scene.environmentIntensity = baseline.environmentIntensity;
+      this.scene.environmentRotation.y = baseline.environmentRotationY;
+      this.sceneLightingBaseline = null;
+    }
+    if (this.lighting) {
+      setRendererToneMappingSource(this.renderer, "environment", null);
+    }
+    const hadEnvBackground = this.sceneBackgroundBaseline !== null;
+    this.lighting = null;
+    if (commit) {
+      this.commitBackground();
+    } else if (hadEnvBackground) {
+      this.restoreBackgroundBaseline();
+      if (!this.passthroughSuppressed) {
         this.scene.background = null;
-      } else {
-        this.signature = null;
       }
     }
-    if (passthrough) {
+  }
+  /**
+   * PMREM-filter an equirect texture. `null` when no usable renderer exists,
+   * or on WebGPU: there the WebGL `PMREMGenerator` would silently produce a
+   * black map, while `WebGPURenderer` prefilters an equirect
+   * `scene.environment` (and a blurred background) by itself.
+   */
+  buildPmrem(texture) {
+    const renderer = this.renderer;
+    if (!renderer || getRendererKindOf(renderer) === "webgpu") return null;
+    let generator = null;
+    try {
+      generator = new THREE19.PMREMGenerator(renderer);
+      return generator.fromEquirectangular(texture);
+    } catch (error) {
+      console.warn(
+        "[EnvironmentSyncSystem] PMREM prefilter failed; using the equirect texture directly.",
+        error
+      );
+      return null;
+    } finally {
+      generator?.dispose();
+    }
+  }
+  loadEnvMap(url) {
+    this.envLoadToken += 1;
+    const token = this.envLoadToken;
+    this.envUrl = url;
+    loadEquirectTexture(url).then(
+      (texture) => {
+        if (this.disposed || token !== this.envLoadToken) {
+          texture.dispose();
+          return;
+        }
+        const target = this.buildPmrem(texture);
+        this.disposeEnvResources();
+        this.envSource = texture;
+        this.envTarget = target;
+        this.scene.environment = target ? target.texture : texture;
+        this.applyEnvironmentParams();
+        this.commitBackground();
+      },
+      (error) => {
+        if (this.disposed || token !== this.envLoadToken) return;
+        console.error(
+          `[EnvironmentSyncSystem] Failed to load environment map ${url}`,
+          error
+        );
+        this.clearEnvMap();
+        this.commitBackground();
+      }
+    );
+  }
+  applyEnvironmentParams() {
+    const lighting = this.lighting;
+    if (!lighting) return;
+    this.scene.environmentIntensity = lighting.envIntensity;
+    this.scene.environmentRotation.y = lighting.envRotationY;
+  }
+  applyLighting(value) {
+    const lighting = normalizeEnvironmentLighting(value);
+    if (!lighting) {
+      if (this.lighting || this.sceneLightingBaseline) {
+        this.clearLighting();
+      }
       return;
     }
+    if (!this.sceneLightingBaseline) {
+      this.sceneLightingBaseline = {
+        environment: this.scene.environment,
+        environmentIntensity: this.scene.environmentIntensity,
+        environmentRotationY: this.scene.environmentRotation.y
+      };
+    }
+    this.lighting = lighting;
+    setRendererToneMappingSource(this.renderer, "environment", {
+      mode: lighting.toneMapping,
+      exposure: lighting.exposure
+    });
+    const url = lighting.envMapUrl.trim();
+    if (!url) {
+      if (this.envUrl !== null || this.envSource) {
+        this.clearEnvMap();
+      }
+    } else if (url !== this.envUrl) {
+      this.loadEnvMap(url);
+    }
+    this.applyEnvironmentParams();
+    this.commitBackground();
+  }
+  resetAll() {
+    this.hasEnvironment = false;
+    this.skyboxSignature = null;
+    this.fogSignature = null;
+    this.lightingSignature = null;
+    this.pendingImageUrl = null;
+    this.disposeActiveTexture();
+    this.skyboxBackground = null;
+    this.clearLighting();
+    this.scene.background = null;
+    this.scene.fog = null;
+  }
+  update(world) {
+    this.renderer = readRenderer(world);
+    const passthrough = world.isXrPassthrough();
+    if (passthrough !== this.passthroughSuppressed) {
+      this.passthroughSuppressed = passthrough;
+      this.commitBackground();
+    }
     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;
+      if (this.hasEnvironment) {
+        this.resetAll();
       }
       return;
     }
@@ -747,29 +1027,50 @@ var _EnvironmentSyncSystem = class _EnvironmentSyncSystem {
     if (!environment) {
       return;
     }
-    const nextSignature = JSON.stringify(environment.values);
-    if (this.signature === nextSignature) {
-      return;
+    this.hasEnvironment = true;
+    const values = environment.values;
+    const skyboxSignature = JSON.stringify(values.skybox);
+    if (skyboxSignature !== this.skyboxSignature) {
+      this.skyboxSignature = skyboxSignature;
+      this.applySkybox(values.skybox);
+    }
+    const fogSignature = JSON.stringify(values.fog);
+    if (fogSignature !== this.fogSignature) {
+      this.fogSignature = fogSignature;
+      this.applyFog(values.fog);
+    }
+    const lightingSignature = JSON.stringify(values.lighting ?? null);
+    if (lightingSignature !== this.lightingSignature) {
+      this.lightingSignature = lightingSignature;
+      this.applyLighting(values.lighting);
     }
-    this.signature = nextSignature;
-    this.applySkybox(environment);
-    this.applyFog(environment);
   }
   dispose() {
     this.pendingImageUrl = null;
     this.disposeActiveTexture();
+    this.clearLighting(false);
+    this.disposed = true;
   }
 };
 __name(_EnvironmentSyncSystem, "EnvironmentSyncSystem");
 var EnvironmentSyncSystem = _EnvironmentSyncSystem;
+
+// core/systems/PostprocessingSyncSystem.ts
 var _PostprocessingSyncSystem = class _PostprocessingSyncSystem {
-  constructor(renderer, scene, camera) {
+  /**
+   * @param backend - Builds the chain. When omitted, the world's backend
+   *   (`world.getRenderBackend()`) is used.
+   */
+  constructor(renderer, scene, camera, backend) {
     this.signature = null;
+    /** Deep copy of the values the current chain reflects. */
+    this.appliedValues = null;
     this.composer = null;
     this.composerEnabled = false;
     this.renderer = renderer;
     this.scene = scene;
     this.camera = camera;
+    this.backend = backend ?? null;
   }
   setComposerEnabled(enabled) {
     this.composerEnabled = enabled;
@@ -779,6 +1080,7 @@ var _PostprocessingSyncSystem = class _PostprocessingSyncSystem {
     }
   }
   disposeComposer() {
+    this.appliedValues = null;
     if (!this.composer) {
       this.setComposerEnabled(false);
       return;
@@ -793,101 +1095,59 @@ var _PostprocessingSyncSystem = class _PostprocessingSyncSystem {
     this.composer = null;
     this.setComposerEnabled(false);
   }
-  buildComposer(values) {
+  /** Ask the renderer for tone mapping while the effect is active. */
+  applyToneMapping(values) {
+    const active = Boolean(values?.postEnabled && values.toneMapping.enabled);
+    setRendererToneMappingSource(
+      this.renderer,
+      "postprocessing",
+      active && values ? { exposure: Math.max(0, values.toneMapping.exposure) } : null
+    );
+  }
+  resolveBackend(world) {
+    return this.backend ?? readWorldRenderBackend(world);
+  }
+  buildComposer(world, values) {
     this.disposeComposer();
+    this.applyToneMapping(values);
     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 THREE19.Vector2());
-      composer.addPass(
-        new UnrealBloomPass(
-          new THREE19.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 THREE19.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);
+    const composer = this.resolveBackend(world).createPostprocessing({
+      renderer: this.renderer,
+      scene: this.scene,
+      camera: this.camera,
+      values,
+      world
+    });
+    if (!composer) {
+      return;
     }
-    composer.addPass(new OutputPass());
     this.composer = composer;
+    this.appliedValues = structuredCloneValues(values);
     this.scene.userData.ecsPostprocessingComposer = composer;
     this.setComposerEnabled(true);
   }
+  /** Update the existing chain in place; `false` when it must be rebuilt. */
+  tryUpdateInPlace(world, values) {
+    const composer = this.composer;
+    const previous = this.appliedValues;
+    if (!composer || !previous || !values.postEnabled) return false;
+    if (this.scene.userData.ecsPostprocessingComposer !== composer) return false;
+    const backend = this.resolveBackend(world);
+    if (typeof backend.updatePostprocessing !== "function") return false;
+    if (!backend.updatePostprocessing(composer, previous, values)) return false;
+    this.appliedValues = structuredCloneValues(values);
+    this.applyToneMapping(values);
+    return true;
+  }
   update(world) {
     const entityIds = world.query(Postprocessing);
     if (entityIds.length === 0) {
       if (this.signature !== null) {
         this.signature = null;
         this.disposeComposer();
+        this.applyToneMapping(null);
         delete this.scene.userData.ecsPostprocessing;
       }
       return;
@@ -901,12 +1161,15 @@ var _PostprocessingSyncSystem = class _PostprocessingSyncSystem {
       return;
     }
     this.signature = nextSignature;
-    this.buildComposer(postprocessing.values);
+    if (!this.tryUpdateInPlace(world, postprocessing.values)) {
+      this.buildComposer(world, postprocessing.values);
+    }
     this.scene.userData.ecsPostprocessing = postprocessing.values;
   }
   dispose() {
     this.signature = null;
     this.disposeComposer();
+    this.applyToneMapping(null);
     delete this.scene.userData.ecsPostprocessing;
     delete this.scene.userData.ecsPostprocessingComposerActive;
     delete this.scene.userData.ecsPostprocessingComposer;
@@ -914,6 +1177,10 @@ var _PostprocessingSyncSystem = class _PostprocessingSyncSystem {
 };
 __name(_PostprocessingSyncSystem, "PostprocessingSyncSystem");
 var PostprocessingSyncSystem = _PostprocessingSyncSystem;
+function structuredCloneValues(values) {
+  return JSON.parse(JSON.stringify(values));
+}
+__name(structuredCloneValues, "structuredCloneValues");
 var MIN_SIZE = 1e-4;
 function toBodyType(RAPIER, bodyType) {
   switch (bodyType) {
@@ -1840,7 +2107,140 @@ var InputSystem = _InputSystem;
 var MIN_LIGHT_DISTANCE = 0;
 var MIN_LIGHT_INTENSITY = 0;
 var MIN_AREA_SIZE = 0.01;
-function applyLightValues(lightComponent) {
+var MIN_SHADOW_MAP_SIZE = 16;
+var MAX_SHADOW_MAP_SIZE = 8192;
+var MIN_SHADOW_NEAR = 1e-3;
+var MIN_SHADOW_CAMERA_SIZE = 0.01;
+var shadowRecords = /* @__PURE__ */ new WeakMap();
+function finiteOrUndefined(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+__name(finiteOrUndefined, "finiteOrUndefined");
+function readShadowRecord(shadow) {
+  let record = shadowRecords.get(shadow);
+  if (!record) {
+    const camera = shadow.camera;
+    record = {
+      baseline: {
+        mapSize: shadow.mapSize.x,
+        bias: shadow.bias,
+        normalBias: shadow.normalBias,
+        radius: shadow.radius,
+        cameraSize: camera.isOrthographicCamera === true && typeof camera.right === "number" ? camera.right : null,
+        near: typeof camera.near === "number" ? camera.near : 0.5,
+        far: typeof camera.far === "number" ? camera.far : 500
+      },
+      applied: /* @__PURE__ */ new Set()
+    };
+    shadowRecords.set(shadow, record);
+  }
+  return record;
+}
+__name(readShadowRecord, "readShadowRecord");
+function resolveShadowField(record, key, provided, fallback) {
+  if (provided !== void 0) {
+    record.applied.add(key);
+    return provided;
+  }
+  if (record.applied.has(key)) {
+    record.applied.delete(key);
+    return fallback;
+  }
+  return void 0;
+}
+__name(resolveShadowField, "resolveShadowField");
+function setShadowMapSize(shadow, size, rendererKind) {
+  if (shadow.mapSize.x === size && shadow.mapSize.y === size) {
+    return;
+  }
+  shadow.mapSize.set(size, size);
+  if (rendererKind === "webgpu") {
+    return;
+  }
+  const map = shadow.map;
+  if (map) {
+    map.depthTexture?.dispose();
+    map.dispose();
+    shadow.map = null;
+  }
+}
+__name(setShadowMapSize, "setShadowMapSize");
+function applyShadowValues(light, shadowValues, rendererKind) {
+  const shadow = light.shadow;
+  if (!shadow) {
+    return;
+  }
+  const values = shadowValues && typeof shadowValues === "object" ? shadowValues : null;
+  if (!values && !shadowRecords.has(shadow)) {
+    return;
+  }
+  const record = readShadowRecord(shadow);
+  const { baseline } = record;
+  const input = values ?? {};
+  const requestedMapSize = finiteOrUndefined(input.mapSize);
+  const mapSize = resolveShadowField(
+    record,
+    "mapSize",
+    requestedMapSize === void 0 ? void 0 : Math.round(
+      Math.min(MAX_SHADOW_MAP_SIZE, Math.max(MIN_SHADOW_MAP_SIZE, requestedMapSize))
+    ),
+    baseline.mapSize
+  );
+  if (mapSize !== void 0) {
+    setShadowMapSize(shadow, mapSize, rendererKind);
+  }
+  const bias = resolveShadowField(record, "bias", finiteOrUndefined(input.bias), baseline.bias);
+  if (bias !== void 0) shadow.bias = bias;
+  const normalBias = resolveShadowField(
+    record,
+    "normalBias",
+    finiteOrUndefined(input.normalBias),
+    baseline.normalBias
+  );
+  if (normalBias !== void 0) shadow.normalBias = normalBias;
+  const radius = resolveShadowField(
+    record,
+    "radius",
+    finiteOrUndefined(input.radius),
+    baseline.radius
+  );
+  if (radius !== void 0) shadow.radius = Math.max(0, radius);
+  const camera = shadow.camera;
+  let cameraChanged = false;
+  if (camera.isOrthographicCamera === true && baseline.cameraSize !== null) {
+    const cameraSize = resolveShadowField(
+      record,
+      "cameraSize",
+      finiteOrUndefined(input.cameraSize),
+      baseline.cameraSize
+    );
+    if (cameraSize !== void 0) {
+      const size = Math.max(MIN_SHADOW_CAMERA_SIZE, cameraSize);
+      camera.left = -size;
+      camera.right = size;
+      camera.top = size;
+      camera.bottom = -size;
+      cameraChanged = true;
+    }
+  }
+  const near = resolveShadowField(record, "near", finiteOrUndefined(input.near), baseline.near);
+  if (near !== void 0) {
+    camera.near = Math.max(MIN_SHADOW_NEAR, near);
+    cameraChanged = true;
+  }
+  const far = resolveShadowField(record, "far", finiteOrUndefined(input.far), baseline.far);
+  if (far !== void 0) {
+    const currentNear = typeof camera.near === "number" ? camera.near : MIN_SHADOW_NEAR;
+    camera.far = Math.max(currentNear + MIN_SHADOW_NEAR, far);
+    cameraChanged = true;
+  }
+  if (cameraChanged) {
+    camera.updateProjectionMatrix?.();
+  }
+  shadow.needsUpdate = true;
+}
+__name(applyShadowValues, "applyShadowValues");
+function applyLightValues(lightComponent, rendererKind) {
   const { light, values } = lightComponent;
   if (typeof values.color === "string") {
     light.color.set(values.color);
@@ -1884,6 +2284,7 @@ function applyLightValues(lightComponent) {
       light.height = Math.max(MIN_AREA_SIZE, values.height);
     }
   }
+  applyShadowValues(light, values.shadow, rendererKind);
 }
 __name(applyLightValues, "applyLightValues");
 var _LightSyncSystem = class _LightSyncSystem {
@@ -1892,6 +2293,7 @@ var _LightSyncSystem = class _LightSyncSystem {
   }
   update(world) {
     const entityIds = world.query(LightComponent);
+    let rendererKind = null;
     const alive = new Set(entityIds);
     for (const trackedId of this.signatures.keys()) {
       if (!alive.has(trackedId)) {
@@ -1907,7 +2309,8 @@ var _LightSyncSystem = class _LightSyncSystem {
       if (this.signatures.get(entityId) === signature) {
         continue;
       }
-      applyLightValues(lightComponent);
+      rendererKind ?? (rendererKind = readWorldRendererKind(world));
+      applyLightValues(lightComponent, rendererKind);
       this.signatures.set(entityId, signature);
     }
   }
@@ -2356,14 +2759,7 @@ __name(_MeshGeometrySystem, "MeshGeometrySystem");
 var MeshGeometrySystem = _MeshGeometrySystem;
 var loadGLTF = /* @__PURE__ */ __name((path) => {
   return new Promise((resolve, reject) => {
-    const loader = new GLTFLoader();
-    try {
-      const dracoLoader = new DRACOLoader();
-      dracoLoader.setDecoderPath(resolveDracoDecoderPath());
-      loader.setDRACOLoader(dracoLoader);
-    } catch (error) {
-      console.debug("DRACOLoader setup failed or unavailable", error);
-    }
+    const loader = createGLTFLoader();
     loader.load(
       path,
       (gltf) => {
@@ -2663,2688 +3059,94 @@ var _InstancedMeshSystem = class _InstancedMeshSystem {
             im.setMatrixAt(i, _matrix);
           }
           im.instanceMatrix.needsUpdate = true;
-          im.castShadow = comp.castShadow;
-          im.receiveShadow = comp.receiveShadow;
-        }
-      }
-    }
-  }
-};
-__name(_InstancedMeshSystem, "InstancedMeshSystem");
-var InstancedMeshSystem = _InstancedMeshSystem;
-
-// 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;
-
-// core/prefab/collectEntitySubtree.ts
-function collectEntitySubtree(world, rootIds) {
-  const childrenByParent = /* @__PURE__ */ new Map();
-  for (const entityId of world.query(ParentId)) {
-    const parentId = world.getComponent(entityId, ParentId)?.value;
-    if (parentId === null || parentId === void 0) {
-      continue;
-    }
-    const siblings = childrenByParent.get(parentId);
-    if (siblings) {
-      siblings.push(entityId);
-    } else {
-      childrenByParent.set(parentId, [entityId]);
-    }
-  }
-  const ordered = [];
-  const seen = /* @__PURE__ */ new Set();
-  const queue = [...rootIds];
-  while (queue.length > 0) {
-    const entityId = queue.shift();
-    if (seen.has(entityId)) {
-      continue;
-    }
-    seen.add(entityId);
-    ordered.push(entityId);
-    const children = childrenByParent.get(entityId);
-    if (children) {
-      queue.push(...children.sort((a, b) => a - b));
-    }
-  }
-  return ordered;
-}
-__name(collectEntitySubtree, "collectEntitySubtree");
-
-// core/hydration/readers.ts
-function asRecord(value) {
-  if (!value || typeof value !== "object") {
-    return null;
-  }
-  return value;
-}
-__name(asRecord, "asRecord");
-function readString(value) {
-  if (typeof value === "string") {
-    return value;
-  }
-  const record = asRecord(value);
-  if (!record) {
-    return null;
-  }
-  return typeof record.value === "string" ? record.value : null;
-}
-__name(readString, "readString");
-function readTransform(value) {
-  const record = asRecord(value);
-  if (!record) {
-    return void 0;
-  }
-  const position = asRecord(record.position);
-  const rotation = asRecord(record.rotation);
-  const scale = asRecord(record.scale);
-  return {
-    position: position ? {
-      x: typeof position.x === "number" ? position.x : void 0,
-      y: typeof position.y === "number" ? position.y : void 0,
-      z: typeof position.z === "number" ? position.z : void 0
-    } : void 0,
-    rotation: rotation ? {
-      x: typeof rotation.x === "number" ? rotation.x : void 0,
-      y: typeof rotation.y === "number" ? rotation.y : void 0,
-      z: typeof rotation.z === "number" ? rotation.z : void 0
-    } : void 0,
-    scale: scale ? {
-      x: typeof scale.x === "number" ? scale.x : void 0,
-      y: typeof scale.y === "number" ? scale.y : void 0,
-      z: typeof scale.z === "number" ? scale.z : void 0
-    } : void 0
-  };
-}
-__name(readTransform, "readTransform");
-function readByComponent(components, componentName) {
-  const component = components.find((entry) => entry.component === componentName);
-  const map = /* @__PURE__ */ new Map();
-  if (!component) {
-    return map;
-  }
-  for (const entry of component.entries) {
-    map.set(entry.entityId, entry.value);
-  }
-  return map;
-}
-__name(readByComponent, "readByComponent");
-function readBoolean(value) {
-  return typeof value === "boolean" ? value : void 0;
-}
-__name(readBoolean, "readBoolean");
-function readNumber(value) {
-  return typeof value === "number" ? value : void 0;
-}
-__name(readNumber, "readNumber");
-
-// core/hydration/componentValues.ts
-function buildComponentValueMaps(snapshot) {
-  return {
-    object3DRefValues: readByComponent(snapshot.components, "Object3DRef"),
-    nameValues: readByComponent(snapshot.components, "Name"),
-    transformValues: readByComponent(snapshot.components, "TransformComponent"),
-    modelValues: readByComponent(snapshot.components, "ModelComponent"),
-    imageValues: readByComponent(snapshot.components, "ImageComponent"),
-    spriteValues: readByComponent(snapshot.components, "SpriteComponent"),
-    videoValues: readByComponent(snapshot.components, "VideoComponent"),
-    cameraValues: readByComponent(snapshot.components, "CameraComponent"),
-    environmentValues: readByComponent(snapshot.components, "Environment"),
-    postprocessingValues: readByComponent(snapshot.components, "Postprocessing"),
-    audioValues: readByComponent(snapshot.components, "AudioComponent"),
-    imageTargetValues: readByComponent(snapshot.components, "ImageTarget"),
-    lightValues: readByComponent(snapshot.components, "LightComponent"),
-    materialValues: readByComponent(snapshot.components, "MaterialComponent"),
-    meshGeometryValues: readByComponent(snapshot.components, "MeshGeometryComponent"),
-    selectableValues: readByComponent(snapshot.components, "Selectable"),
-    physicsValues: readByComponent(snapshot.components, "PhysicsComponent"),
-    animationValues: readByComponent(snapshot.components, "AnimationComponent"),
-    imageTargetAnchorValues: readByComponent(snapshot.components, "ImageTargetAnchor"),
-    scriptValues: readByComponent(snapshot.components, "ScriptComponent"),
-    scriptObjectValues: readByComponent(
-      snapshot.components,
-      "ScriptObjectComponent"
-    ),
-    xrRigValues: readByComponent(snapshot.components, "XRRigComponent"),
-    vrTeleportAreaValues: readByComponent(
-      snapshot.components,
-      "VRTeleportAreaComponent"
-    ),
-    xrInteractableValues: readByComponent(
-      snapshot.components,
-      "XRInteractableComponent"
-    ),
-    xrInteractorValues: readByComponent(
-      snapshot.components,
-      "XRInteractorComponent"
-    ),
-    xrHandPoseValues: readByComponent(
-      snapshot.components,
-      "XRHandPoseComponent"
-    ),
-    xrAnchorValues: readByComponent(snapshot.components, "XRAnchorComponent"),
-    uiPanelValues: readByComponent(snapshot.components, "UIPanelComponent"),
-    uiTextValues: readByComponent(snapshot.components, "UITextComponent"),
-    uiButtonValues: readByComponent(snapshot.components, "UIButtonComponent"),
-    uiToggleValues: readByComponent(snapshot.components, "UIToggleComponent"),
-    uiSliderValues: readByComponent(snapshot.components, "UISliderComponent"),
-    xrInteractorSideValues: readByComponent(
-      snapshot.components,
-      "XRInteractorSideComponent"
-    ),
-    instancedMeshValues: readByComponent(snapshot.components, "InstancedMeshComponent"),
-    instanceSlotValues: readByComponent(snapshot.components, "InstanceSlotComponent"),
-    prefabNodeValues: readByComponent(snapshot.components, "PrefabNode"),
-    prefabInstanceValues: readByComponent(snapshot.components, "PrefabInstance")
-  };
-}
-__name(buildComponentValueMaps, "buildComponentValueMaps");
-
-// core/hydration/parentLinks.ts
-function applyParentLinks(snapshot, idMap, objectManagementSystem, world) {
-  const parentValues = readByComponent(snapshot.components, "ParentId");
-  for (const [sourceEntityId, parentValue] of parentValues.entries()) {
-    const targetEntityId = idMap.get(sourceEntityId);
-    if (targetEntityId === void 0) {
-      continue;
-    }
-    const parentRecord = asRecord(parentValue);
-    const sourceParentId = parentRecord && typeof parentRecord.value === "number" ? parentRecord.value : null;
-    if (sourceParentId === null) {
-      objectManagementSystem.setParent(world, targetEntityId, null, {
-        preserveWorldTransform: false
-      });
-      continue;
-    }
-    const mappedParentId = idMap.get(sourceParentId);
-    objectManagementSystem.setParent(world, targetEntityId, mappedParentId ?? null, {
-      preserveWorldTransform: false
-    });
-  }
-}
-__name(applyParentLinks, "applyParentLinks");
-
-// core/hydration/postCreateComponents.ts
-function remapEntityRefsInScriptData(data, idMap) {
-  const result = {};
-  for (const [key, value] of Object.entries(data)) {
-    if (value !== null && typeof value === "object" && !Array.isArray(value)) {
-      const v = value;
-      if (v.type === "entity" && typeof v.value === "number") {
-        result[key] = { ...v, value: idMap.get(v.value) ?? v.value };
-      } else if (v.type === "component" && v.value !== null && typeof v.value === "object" && !Array.isArray(v.value) && typeof v.value.entityId === "number") {
-        const ref = v.value;
-        result[key] = {
-          ...v,
-          value: { ...ref, entityId: idMap.get(ref.entityId) ?? ref.entityId }
-        };
-      } else {
-        result[key] = value;
-      }
-    } else {
-      result[key] = value;
-    }
-  }
-  return result;
-}
-__name(remapEntityRefsInScriptData, "remapEntityRefsInScriptData");
-function restorePostCreateComponents(world, objectManagementSystem, targetEntityId, sourceEntityId, entityType, values, idMap) {
-  const objectRef = world.getComponent(targetEntityId, Object3DRef)?.object ?? null;
-  const sourceAudio = asRecord(values.audioValues.get(sourceEntityId));
-  if (sourceAudio && entityType !== "audio") {
-    const sourceOptions = asRecord(sourceAudio.options) ?? {};
-    objectManagementSystem.createComponentNow(
-      "audio",
-      world,
-      targetEntityId,
-      typeof sourceAudio.path === "string" ? sourceAudio.path : "",
-      sourceOptions,
-      {
-        object: objectRef,
-        listener: objectManagementSystem.getOrCreateAudioListener(),
-        isEditor: objectManagementSystem.isEditorMode()
-      }
-    );
-  }
-  const sourceImageTarget = asRecord(values.imageTargetValues.get(sourceEntityId));
-  if (sourceImageTarget && entityType !== "imageTarget") {
-    objectManagementSystem.createComponentNow(
-      "imageTarget",
-      world,
-      targetEntityId,
-      {
-        targets: Array.isArray(sourceImageTarget.targets) ? sourceImageTarget.targets : [],
-        compiledTargetUrl: typeof sourceImageTarget.compiledTargetUrl === "string" ? sourceImageTarget.compiledTargetUrl : void 0,
-        compiledTargetDir: typeof sourceImageTarget.compiledTargetDir === "string" ? sourceImageTarget.compiledTargetDir : void 0
-      }
-    );
-  }
-  const sourceImageTargetAnchor = asRecord(values.imageTargetAnchorValues.get(sourceEntityId));
-  if (sourceImageTargetAnchor) {
-    const mappedTargetId = typeof sourceImageTargetAnchor.targetId === "number" && Number.isFinite(sourceImageTargetAnchor.targetId) ? sourceImageTargetAnchor.targetId : null;
-    objectManagementSystem.createComponentNow("imageTargetAnchor", world, targetEntityId, {
-      targetId: mappedTargetId,
-      targetUrl: typeof sourceImageTargetAnchor.targetUrl === "string" ? sourceImageTargetAnchor.targetUrl : void 0
-    });
-  }
-  const sourceScript = asRecord(values.scriptValues.get(sourceEntityId));
-  if (sourceScript) {
-    const entries = Array.isArray(sourceScript.entries) ? sourceScript.entries.map((entry) => asRecord(entry)).filter((entry) => Boolean(entry)).map((entry) => {
-      const runtimeState = entry.runtimeState === "idle" || entry.runtimeState === "loading" || entry.runtimeState === "ready" || entry.runtimeState === "error" ? entry.runtimeState : void 0;
-      return {
-        entityId: targetEntityId,
-        className: typeof entry.className === "string" ? entry.className : "",
-        scriptUrl: typeof entry.scriptUrl === "string" ? entry.scriptUrl : "",
-        enabled: typeof entry.enabled === "boolean" ? entry.enabled : true,
-        data: entry.data && typeof entry.data === "object" && !Array.isArray(entry.data) ? remapEntityRefsInScriptData(entry.data, idMap) : {},
-        runtimeState,
-        runtimeMessage: typeof entry.runtimeMessage === "string" ? entry.runtimeMessage : void 0
-      };
-    }).filter((entry) => entry.className || entry.scriptUrl) : [];
-    if (entries.length) {
-      world.addComponent(targetEntityId, new ScriptComponent(entries));
-    }
-  }
-  const sourceScriptObject = asRecord(values.scriptObjectValues.get(sourceEntityId));
-  if (sourceScriptObject) {
-    const soc = world.getComponent(targetEntityId, ScriptObjectComponent);
-    const data = asRecord(sourceScriptObject.data);
-    if (soc && data) {
-      soc.data = remapEntityRefsInScriptData(data, idMap);
-    }
-  }
-  {
-    const sourceXrRig = asRecord(values.xrRigValues.get(sourceEntityId));
-    const rig = world.getComponent(targetEntityId, XRRigComponent);
-    if (sourceXrRig && rig) {
-      if (typeof sourceXrRig.locomotion === "string") {
-        rig.locomotion = sourceXrRig.locomotion;
-      }
-      if (typeof sourceXrRig.moveSpeed === "number") {
-        rig.moveSpeed = sourceXrRig.moveSpeed;
-      }
-      if (typeof sourceXrRig.snapTurn === "boolean") {
-        rig.snapTurn = sourceXrRig.snapTurn;
-      }
-      if (typeof sourceXrRig.snapTurnDegrees === "number") {
-        rig.snapTurnDegrees = sourceXrRig.snapTurnDegrees;
-      }
-      if (typeof sourceXrRig.teleportArcColor === "string") {
-        rig.teleportArcColor = sourceXrRig.teleportArcColor;
-      }
-      if (typeof sourceXrRig.teleportArcInvalidColor === "string") {
-        rig.teleportArcInvalidColor = sourceXrRig.teleportArcInvalidColor;
-      }
-      if (typeof sourceXrRig.teleportArcThickness === "number") {
-        rig.teleportArcThickness = sourceXrRig.teleportArcThickness;
-      }
-      if (typeof sourceXrRig.fallbackEyeHeight === "number") {
-        rig.fallbackEyeHeight = sourceXrRig.fallbackEyeHeight;
-      }
-      if (typeof sourceXrRig.passthrough === "boolean") {
-        rig.passthrough = sourceXrRig.passthrough;
-      }
-      if (typeof sourceXrRig.depthOcclusion === "boolean") {
-        rig.depthOcclusion = sourceXrRig.depthOcclusion;
-      }
-      if (typeof sourceXrRig.environmentPhysics === "string") {
-        rig.environmentPhysics = sourceXrRig.environmentPhysics;
-      }
-      if (typeof sourceXrRig.environmentDebug === "boolean") {
-        rig.environmentDebug = sourceXrRig.environmentDebug;
-      }
-      if (typeof sourceXrRig.hitTest === "boolean") {
-        rig.hitTest = sourceXrRig.hitTest;
-      }
-      if (typeof sourceXrRig.anchors === "boolean") {
-        rig.anchors = sourceXrRig.anchors;
-      }
-    }
-  }
-  {
-    const sourceArea = asRecord(values.vrTeleportAreaValues.get(sourceEntityId));
-    const area = world.getComponent(targetEntityId, VRTeleportAreaComponent);
-    if (sourceArea && area) {
-      if (typeof sourceArea.enabled === "boolean") {
-        area.enabled = sourceArea.enabled;
-      }
-      if (typeof sourceArea.shape === "string") {
-        area.shape = sourceArea.shape === "cylinder" ? "circle" : sourceArea.shape;
-      }
-      if (typeof sourceArea.width === "number") area.width = sourceArea.width;
-      if (typeof sourceArea.depth === "number") area.depth = sourceArea.depth;
-    }
-  }
-  {
-    const sourceInteractable = asRecord(
-      values.xrInteractableValues.get(sourceEntityId)
-    );
-    let interactable = world.getComponent(
-      targetEntityId,
-      XRInteractableComponent
-    );
-    if (sourceInteractable && !interactable) {
-      interactable = new XRInteractableComponent();
-      world.addComponent(targetEntityId, interactable);
-    }
-    if (sourceInteractable && interactable) {
-      if (typeof sourceInteractable.enabled === "boolean") {
-        interactable.enabled = sourceInteractable.enabled;
-      }
-      if (typeof sourceInteractable.grabbable === "boolean") {
-        interactable.grabbable = sourceInteractable.grabbable;
-      }
-      if (typeof sourceInteractable.pointable === "boolean") {
-        interactable.pointable = sourceInteractable.pointable;
-      }
-      if (typeof sourceInteractable.grabReach === "string") {
-        interactable.grabReach = sourceInteractable.grabReach;
-      }
-      if (typeof sourceInteractable.distanceBehavior === "string") {
-        interactable.distanceBehavior = sourceInteractable.distanceBehavior;
-      }
-      if (typeof sourceInteractable.grabGesture === "string") {
-        interactable.grabGesture = sourceInteractable.grabGesture;
-      }
-      if (typeof sourceInteractable.grabRadius === "number") {
-        interactable.grabRadius = sourceInteractable.grabRadius;
-      }
-      if (typeof sourceInteractable.grabHands === "string") {
-        interactable.grabHands = sourceInteractable.grabHands;
-      }
-      if (typeof sourceInteractable.twoHandRotation === "string") {
-        interactable.twoHandRotation = sourceInteractable.twoHandRotation;
-      }
-      if (typeof sourceInteractable.allowTwoHandScale === "boolean") {
-        interactable.allowTwoHandScale = sourceInteractable.allowTwoHandScale;
-      }
-      if (typeof sourceInteractable.minScale === "number") {
-        interactable.minScale = sourceInteractable.minScale;
-      }
-      if (typeof sourceInteractable.maxScale === "number") {
-        interactable.maxScale = sourceInteractable.maxScale;
-      }
-      if (Array.isArray(sourceInteractable.attachPoints)) {
-        interactable.attachPoints = sourceInteractable.attachPoints.map((point) => asRecord(point)).filter(
-          (point) => point !== null && typeof point.id === "string"
-        ).map(
-          (point) => createAttachPoint(
-            point
-          )
-        );
-      }
-      if (typeof sourceInteractable.applyVelocityOnRelease === "boolean") {
-        interactable.applyVelocityOnRelease = sourceInteractable.applyVelocityOnRelease;
-      } else if (typeof sourceInteractable.throwOnRelease === "boolean") {
-        interactable.applyVelocityOnRelease = sourceInteractable.throwOnRelease;
-      }
-      if (typeof sourceInteractable.velocityScale === "number") {
-        interactable.velocityScale = sourceInteractable.velocityScale;
-      } else if (typeof sourceInteractable.throwStrength === "number") {
-        interactable.velocityScale = sourceInteractable.throwStrength;
-      }
-      const grabPos = asRecord(sourceInteractable.grabOffsetPosition);
-      if (grabPos) {
-        interactable.grabOffsetPosition = {
-          x: typeof grabPos.x === "number" ? grabPos.x : 0,
-          y: typeof grabPos.y === "number" ? grabPos.y : 0,
-          z: typeof grabPos.z === "number" ? grabPos.z : 0
-        };
-      }
-      const grabRot = asRecord(sourceInteractable.grabOffsetRotation);
-      if (grabRot) {
-        interactable.grabOffsetRotation = {
-          x: typeof grabRot.x === "number" ? grabRot.x : 0,
-          y: typeof grabRot.y === "number" ? grabRot.y : 0,
-          z: typeof grabRot.z === "number" ? grabRot.z : 0
-        };
-      }
-      if (typeof sourceInteractable.hoverBehavior === "string") {
-        interactable.hoverBehavior = sourceInteractable.hoverBehavior;
-      } else if (sourceInteractable.highlightOnHover === false) {
-        interactable.hoverBehavior = "none";
-      }
-      if (typeof sourceInteractable.hoverColor === "string") {
-        interactable.hoverColor = sourceInteractable.hoverColor;
-      }
-      if (typeof sourceInteractable.hoverScale === "number") {
-        interactable.hoverScale = sourceInteractable.hoverScale;
-      }
-    }
-  }
-  {
-    const sourceHandPose = asRecord(
-      values.xrHandPoseValues.get(sourceEntityId)
-    );
-    let handPose = world.getComponent(targetEntityId, XRHandPoseComponent);
-    if (sourceHandPose && !handPose) {
-      handPose = new XRHandPoseComponent();
-      world.addComponent(targetEntityId, handPose);
-    }
-    if (sourceHandPose && handPose) {
-      if (typeof sourceHandPose.enabled === "boolean") {
-        handPose.enabled = sourceHandPose.enabled;
-      }
-      if (Array.isArray(sourceHandPose.poses)) {
-        handPose.poses = sourceHandPose.poses.map((entry) => asRecord(entry)).filter(
-          (entry) => entry !== null && typeof entry.id === "string"
-        ).map(
-          (entry) => createHandPoseEntry(
-            entry
-          )
-        );
-      }
-    }
-  }
-  {
-    const sourceAnchor = asRecord(values.xrAnchorValues.get(sourceEntityId));
-    let anchor = world.getComponent(targetEntityId, XRAnchorComponent);
-    if (sourceAnchor && !anchor) {
-      anchor = new XRAnchorComponent();
-      world.addComponent(targetEntityId, anchor);
-    }
-    if (sourceAnchor && anchor) {
-      if (typeof sourceAnchor.enabled === "boolean") {
-        anchor.enabled = sourceAnchor.enabled;
-      }
-    }
-  }
-  {
-    const restoreUi = /* @__PURE__ */ __name((map, Ctor, existing) => {
-      const source = asRecord(map.get(sourceEntityId));
-      if (!source) return;
-      let component = existing;
-      if (!component) {
-        component = new Ctor();
-        world.addComponent(targetEntityId, component);
-      }
-      const target = component;
-      for (const [key, value] of Object.entries(source)) {
-        const current = target[key];
-        if ((typeof value === "string" || typeof value === "number" || typeof value === "boolean") && typeof current === typeof value) {
-          target[key] = value;
-        }
-      }
-    }, "restoreUi");
-    restoreUi(
-      values.uiPanelValues,
-      UIPanelComponent,
-      world.getComponent(targetEntityId, UIPanelComponent)
-    );
-    restoreUi(
-      values.uiTextValues,
-      UITextComponent,
-      world.getComponent(targetEntityId, UITextComponent)
-    );
-    restoreUi(
-      values.uiButtonValues,
-      UIButtonComponent,
-      world.getComponent(targetEntityId, UIButtonComponent)
-    );
-    restoreUi(
-      values.uiToggleValues,
-      UIToggleComponent,
-      world.getComponent(targetEntityId, UIToggleComponent)
-    );
-    restoreUi(
-      values.uiSliderValues,
-      UISliderComponent,
-      world.getComponent(targetEntityId, UISliderComponent)
-    );
-  }
-  {
-    const sourceInteractor = asRecord(
-      values.xrInteractorValues.get(sourceEntityId)
-    );
-    const interactor = world.getComponent(targetEntityId, XRInteractorComponent);
-    if (sourceInteractor && interactor) {
-      if (typeof sourceInteractor.interactorType === "string") {
-        interactor.interactorType = sourceInteractor.interactorType;
-      }
-      if (typeof sourceInteractor.handPreset === "string") {
-        interactor.handPreset = sourceInteractor.handPreset;
-      }
-      if (typeof sourceInteractor.handColor === "string") {
-        interactor.handColor = sourceInteractor.handColor;
-      }
-      if (typeof sourceInteractor.handOpacity === "number") {
-        interactor.handOpacity = sourceInteractor.handOpacity;
-      }
-      if (typeof sourceInteractor.handEmissiveIntensity === "number") {
-        interactor.handEmissiveIntensity = sourceInteractor.handEmissiveIntensity;
-      }
-      if (typeof sourceInteractor.rayVisibility === "string") {
-        interactor.rayVisibility = sourceInteractor.rayVisibility;
-      } else if (typeof sourceInteractor.showRay === "boolean") {
-        interactor.rayVisibility = sourceInteractor.showRay ? "interacting" : "never";
-      }
-      if (typeof sourceInteractor.rayColor === "string") {
-        interactor.rayColor = sourceInteractor.rayColor;
-      }
-      if (typeof sourceInteractor.rayThickness === "number") {
-        interactor.rayThickness = sourceInteractor.rayThickness;
-      }
-    }
-  }
-  {
-    const sourceSide = asRecord(
-      values.xrInteractorSideValues.get(sourceEntityId)
-    );
-    if (sourceSide && typeof sourceSide.side === "string") {
-      const existing = world.getComponent(
-        targetEntityId,
-        XRInteractorSideComponent
-      );
-      if (existing) {
-        existing.side = sourceSide.side;
-      } else {
-        world.addComponent(
-          targetEntityId,
-          new XRInteractorSideComponent({
-            side: sourceSide.side
-          })
-        );
-      }
-    }
-  }
-  {
-    const sourceRigOrigin = asRecord(values.xrRigValues.get(sourceEntityId));
-    const rigForOrigin = world.getComponent(targetEntityId, XRRigComponent);
-    if (sourceRigOrigin && rigForOrigin && typeof sourceRigOrigin.trackingOrigin === "string") {
-      rigForOrigin.trackingOrigin = sourceRigOrigin.trackingOrigin;
-    }
-  }
-  {
-    const imComponent = world.getComponent(targetEntityId, InstancedMeshComponent);
-    if (imComponent && imComponent.instanceEntityIds.length > 0) {
-      imComponent.instanceEntityIds = imComponent.instanceEntityIds.map(
-        (oldId) => idMap.get(oldId) ?? oldId
-      );
-    }
-  }
-  {
-    const slotComponent = world.getComponent(targetEntityId, InstanceSlotComponent);
-    if (slotComponent && slotComponent.groupEntityId !== -1) {
-      slotComponent.groupEntityId = idMap.get(slotComponent.groupEntityId) ?? slotComponent.groupEntityId;
-    }
-  }
-}
-__name(restorePostCreateComponents, "restorePostCreateComponents");
-
-// core/hydration/animation.ts
-function readAnimationClipName(value) {
-  if (typeof value === "string") {
-    return value;
-  }
-  const record = asRecord(value);
-  if (!record) {
-    return null;
-  }
-  if (typeof record.name === "string") {
-    return record.name;
-  }
-  return null;
-}
-__name(readAnimationClipName, "readAnimationClipName");
-function readAnimationStates(value) {
-  if (!Array.isArray(value)) {
-    return [];
-  }
-  const states = [];
-  for (const entry of value) {
-    const state = asRecord(entry);
-    if (!state) {
-      continue;
-    }
-    const name = typeof state.name === "string" ? state.name : null;
-    const clip = readAnimationClipName(state.clip);
-    if (!name || !clip) {
-      continue;
-    }
-    states.push({
-      name,
-      clip,
-      clipId: typeof state.clipId === "string" ? state.clipId : void 0,
-      loop: typeof state.loop === "boolean" ? state.loop : false
-    });
-  }
-  return states;
-}
-__name(readAnimationStates, "readAnimationStates");
-function readAnimationClipSources(value) {
-  if (!Array.isArray(value)) {
-    return [];
-  }
-  const seen = /* @__PURE__ */ new Set();
-  const sources = [];
-  for (const entry of value) {
-    if (typeof entry !== "string") {
-      continue;
-    }
-    const trimmed = entry.trim();
-    if (!trimmed || seen.has(trimmed)) {
-      continue;
-    }
-    seen.add(trimmed);
-    sources.push(trimmed);
-  }
-  return sources;
-}
-__name(readAnimationClipSources, "readAnimationClipSources");
-function toAnimationOptions(sourceAnimation) {
-  const paused = readBoolean(sourceAnimation.paused);
-  const reverse = readBoolean(sourceAnimation.reverse);
-  const timeScale = readNumber(sourceAnimation.timeScale);
-  const crossFadeDuration = readNumber(sourceAnimation.crossFadeDuration);
-  const states = readAnimationStates(sourceAnimation.states);
-  const externalClipSources = readAnimationClipSources(
-    sourceAnimation.externalClipSources
-  );
-  const activeStateName = typeof sourceAnimation.activeStateName === "string" ? sourceAnimation.activeStateName : typeof sourceAnimation.activeState === "string" ? sourceAnimation.activeState : typeof sourceAnimation.active?.name === "string" ? sourceAnimation.active.name ?? null : null;
-  return {
-    paused,
-    reverse,
-    timeScale,
-    crossFadeDuration,
-    states,
-    externalClipSources,
-    activeState: activeStateName
-  };
-}
-__name(toAnimationOptions, "toAnimationOptions");
-function restoreAnimationComponent(world, objectManagementSystem, targetEntityId, sourceAnimation) {
-  const options = toAnimationOptions(sourceAnimation);
-  let animation = world.getComponent(targetEntityId, AnimationComponent);
-  if (!animation) {
-    objectManagementSystem.createComponentNow(
-      "animation",
-      world,
-      targetEntityId,
-      options
-    );
-    animation = world.getComponent(targetEntityId, AnimationComponent);
-  }
-  if (!animation) {
-    return;
-  }
-  const availableClips = Array.isArray(sourceAnimation.availableClips) ? sourceAnimation.availableClips.filter(
-    (clip) => typeof clip === "string" && clip.length > 0
-  ) : [];
-  if (availableClips.length > 0) {
-    animation.availableClips = [...availableClips];
-  }
-  if (Array.isArray(options.externalClipSources)) {
-    animation.setExternalClipSources(options.externalClipSources);
-  }
-  const states = options.states ?? [];
-  const hasClips = Array.isArray(animation.clips) && animation.clips.length > 0;
-  if (!hasClips) {
-    animation.__pendingHydratedOptions = options;
-    if (typeof options.reverse === "boolean") {
-      animation.reverse = options.reverse;
-    }
-    if (typeof options.timeScale === "number") {
-      animation.timeScale = options.timeScale;
-    }
-    if (typeof options.crossFadeDuration === "number") {
-      animation.crossFadeDuration = options.crossFadeDuration;
-    }
-    if (typeof options.paused === "boolean") {
-      animation.paused = options.paused;
-    }
-    return;
-  }
-  if (states.length > 0) {
-    animation.setStates(states);
-  }
-  if (typeof options.reverse === "boolean") {
-    animation.reverse = options.reverse;
-  }
-  if (typeof options.timeScale === "number") {
-    animation.timeScale = options.timeScale;
-  }
-  if (typeof options.crossFadeDuration === "number") {
-    animation.crossFadeDuration = options.crossFadeDuration;
-  }
-  if (typeof options.activeState === "string" && options.activeState.length > 0) {
-    animation.setActiveState(options.activeState, !options.paused);
-  }
-  if (typeof options.paused === "boolean") {
-    if (options.paused) {
-      animation.pauseState();
-    } else if (typeof options.activeState === "string" && options.activeState.length > 0) {
-      animation.playState(options.activeState);
-    }
-  }
-}
-__name(restoreAnimationComponent, "restoreAnimationComponent");
-
-// core/hydration/restoreComponentState.ts
-function readEnvironmentState(value) {
-  const record = asRecord(value);
-  if (!record) {
-    return null;
-  }
-  const nestedValues = asRecord(record.values);
-  if (nestedValues) {
-    return nestedValues;
-  }
-  return record;
-}
-__name(readEnvironmentState, "readEnvironmentState");
-function readPostprocessingState(value) {
-  const record = asRecord(value);
-  if (!record) {
-    return null;
-  }
-  const nestedValues = asRecord(record.values);
-  if (nestedValues) {
-    return nestedValues;
-  }
-  return record;
-}
-__name(readPostprocessingState, "readPostprocessingState");
-function restoreComponentState(world, objectManagementSystem, targetEntityId, sourceEntityId, entityType, values) {
-  const sourceName = readString(values.nameValues.get(sourceEntityId));
-  if (sourceName !== null) {
-    const nameComponent = world.getComponent(targetEntityId, Name);
-    if (nameComponent) {
-      nameComponent.value = sourceName;
-    }
-  }
-  const sourceObject3DRef = asRecord(values.object3DRefValues.get(sourceEntityId));
-  if (sourceObject3DRef) {
-    const object3DRefComponent = world.getComponent(targetEntityId, Object3DRef);
-    const visibility = readBoolean(sourceObject3DRef.visibility);
-    if (object3DRefComponent && typeof visibility === "boolean") {
-      object3DRefComponent.visibility = visibility;
-    }
-  }
-  const sourceTransform = readTransform(values.transformValues.get(sourceEntityId));
-  if (sourceTransform) {
-    const transformComponent = world.getComponent(targetEntityId, TransformComponent);
-    if (transformComponent) {
-      if (typeof sourceTransform.position?.x === "number") {
-        transformComponent.position.x = sourceTransform.position.x;
-      }
-      if (typeof sourceTransform.position?.y === "number") {
-        transformComponent.position.y = sourceTransform.position.y;
-      }
-      if (typeof sourceTransform.position?.z === "number") {
-        transformComponent.position.z = sourceTransform.position.z;
-      }
-      if (typeof sourceTransform.rotation?.x === "number") {
-        transformComponent.rotation.x = sourceTransform.rotation.x;
-      }
-      if (typeof sourceTransform.rotation?.y === "number") {
-        transformComponent.rotation.y = sourceTransform.rotation.y;
-      }
-      if (typeof sourceTransform.rotation?.z === "number") {
-        transformComponent.rotation.z = sourceTransform.rotation.z;
-      }
-      if (typeof sourceTransform.scale?.x === "number") {
-        transformComponent.scale.x = sourceTransform.scale.x;
-      }
-      if (typeof sourceTransform.scale?.y === "number") {
-        transformComponent.scale.y = sourceTransform.scale.y;
-      }
-      if (typeof sourceTransform.scale?.z === "number") {
-        transformComponent.scale.z = sourceTransform.scale.z;
-      }
-    }
-  }
-  const sourceModel = asRecord(values.modelValues.get(sourceEntityId));
-  if (sourceModel) {
-    const modelComponent = world.getComponent(targetEntityId, ModelComponent);
-    if (modelComponent && typeof sourceModel.path === "string") {
-      modelComponent.path = sourceModel.path;
-    }
-  }
-  const sourceImage = asRecord(values.imageValues.get(sourceEntityId));
-  if (sourceImage) {
-    const imageComponent = world.getComponent(targetEntityId, ImageComponent);
-    if (imageComponent) {
-      if (typeof sourceImage.path === "string") {
-        imageComponent.path = sourceImage.path;
-      }
-      const width = readNumber(sourceImage.width);
-      if (typeof width === "number") {
-        imageComponent.width = width;
-      }
-      const height = readNumber(sourceImage.height);
-      if (typeof height === "number") {
-        imageComponent.height = height;
-      }
-    }
-  }
-  const sourceSprite = asRecord(values.spriteValues.get(sourceEntityId));
-  if (sourceSprite) {
-    const spriteComponent = world.getComponent(targetEntityId, SpriteComponent);
-    if (spriteComponent) {
-      if (typeof sourceSprite.path === "string") {
-        spriteComponent.path = sourceSprite.path;
-      }
-      const width = readNumber(sourceSprite.width);
-      if (typeof width === "number") {
-        spriteComponent.width = width;
-      }
-      const height = readNumber(sourceSprite.height);
-      if (typeof height === "number") {
-        spriteComponent.height = height;
-      }
-    }
-  }
-  const sourceVideo = asRecord(values.videoValues.get(sourceEntityId));
-  if (sourceVideo) {
-    const videoComponent = world.getComponent(targetEntityId, VideoComponent);
-    if (videoComponent) {
-      if (typeof sourceVideo.path === "string") {
-        videoComponent.path = sourceVideo.path;
-      }
-      const videoOptions = asRecord(sourceVideo.options);
-      if (videoOptions) {
-        videoComponent.options = {
-          ...videoComponent.options,
-          ...videoOptions
-        };
-      }
-    }
-  }
-  const sourceAudio = asRecord(values.audioValues.get(sourceEntityId));
-  if (sourceAudio && entityType === "audio") {
-    const audioComponent = world.getComponent(targetEntityId, AudioComponent);
-    if (audioComponent) {
-      if (typeof sourceAudio.path === "string") {
-        audioComponent.path = sourceAudio.path;
-      }
-      const audioOptions = asRecord(sourceAudio.options);
-      if (audioOptions) {
-        audioComponent.options = {
-          ...audioComponent.options,
-          ...audioOptions
-        };
-      }
-    }
-  }
-  const sourceCamera = asRecord(values.cameraValues.get(sourceEntityId));
-  if (sourceCamera) {
-    const cameraComponent = world.getComponent(targetEntityId, CameraComponent);
-    if (cameraComponent) {
-      if (sourceCamera.projection === "orthographic" || sourceCamera.projection === "perspective") {
-        cameraComponent.projection = sourceCamera.projection;
-      }
-      if (sourceCamera.type === "3d" || sourceCamera.type === "ar") {
-        cameraComponent.type = sourceCamera.type;
-      }
-      if (typeof sourceCamera.isDefault === "boolean") {
-        cameraComponent.isDefault = sourceCamera.isDefault;
-      }
-      const fov = readNumber(sourceCamera.fov);
-      if (typeof fov === "number") {
-        cameraComponent.fov = fov;
-      }
-      const near = readNumber(sourceCamera.near);
-      if (typeof near === "number") {
-        cameraComponent.near = near;
-      }
-      const far = readNumber(sourceCamera.far);
-      if (typeof far === "number") {
-        cameraComponent.far = far;
-      }
-      const left = readNumber(sourceCamera.left);
-      if (typeof left === "number") {
-        cameraComponent.left = left;
-      }
-      const right = readNumber(sourceCamera.right);
-      if (typeof right === "number") {
-        cameraComponent.right = right;
-      }
-      const top = readNumber(sourceCamera.top);
-      if (typeof top === "number") {
-        cameraComponent.top = top;
-      }
-      const bottom = readNumber(sourceCamera.bottom);
-      if (typeof bottom === "number") {
-        cameraComponent.bottom = bottom;
-      }
-      const zoom = readNumber(sourceCamera.zoom);
-      if (typeof zoom === "number") {
-        cameraComponent.zoom = zoom;
-      }
-    }
-  }
-  const sourceEnvironment = readEnvironmentState(
-    values.environmentValues.get(sourceEntityId)
-  );
-  if (sourceEnvironment) {
-    let environmentComponent = world.getComponent(targetEntityId, Environment);
-    if (!environmentComponent) {
-      objectManagementSystem.createComponentNow(
-        "environment",
-        world,
-        targetEntityId,
-        sourceEnvironment
-      );
-      environmentComponent = world.getComponent(targetEntityId, Environment);
-    }
-    if (environmentComponent) {
-      environmentComponent.values = new Environment({
-        ...environmentComponent.values,
-        ...sourceEnvironment
-      }).values;
-    }
-  }
-  const sourcePostprocessing = readPostprocessingState(
-    values.postprocessingValues.get(sourceEntityId)
-  );
-  if (sourcePostprocessing) {
-    let postprocessingComponent = world.getComponent(targetEntityId, Postprocessing);
-    if (!postprocessingComponent) {
-      objectManagementSystem.createComponentNow(
-        "postprocessing",
-        world,
-        targetEntityId,
-        sourcePostprocessing
-      );
-      postprocessingComponent = world.getComponent(targetEntityId, Postprocessing);
-    }
-    if (postprocessingComponent) {
-      postprocessingComponent.values = new Postprocessing({
-        ...postprocessingComponent.values,
-        ...sourcePostprocessing
-      }).values;
-    }
-  }
-  const sourceImageTarget = asRecord(values.imageTargetValues.get(sourceEntityId));
-  if (sourceImageTarget && entityType === "imageTarget") {
-    const imageTargetComponent = world.getComponent(targetEntityId, ImageTarget);
-    if (imageTargetComponent) {
-      imageTargetComponent.targets = Array.isArray(sourceImageTarget.targets) ? sourceImageTarget.targets : [];
-      imageTargetComponent.compiledTargetUrl = typeof sourceImageTarget.compiledTargetUrl === "string" ? sourceImageTarget.compiledTargetUrl : void 0;
-      imageTargetComponent.compiledTargetDir = typeof sourceImageTarget.compiledTargetDir === "string" ? sourceImageTarget.compiledTargetDir : void 0;
-    }
-  }
-  const sourceLight = asRecord(values.lightValues.get(sourceEntityId));
-  if (sourceLight) {
-    const lightComponent = world.getComponent(targetEntityId, LightComponent);
-    const sourceValues = asRecord(sourceLight.values);
-    if (lightComponent && sourceValues) {
-      lightComponent.values = {
-        ...lightComponent.values,
-        ...sourceValues
-      };
-    }
-  }
-  const sourceMaterial = asRecord(values.materialValues.get(sourceEntityId));
-  if (sourceMaterial) {
-    const materialComponent = world.getComponent(targetEntityId, MaterialComponent);
-    const sourceValues = sourceMaterial.values;
-    if (materialComponent && Array.isArray(sourceValues)) {
-      materialComponent.values = sourceValues;
-    }
-    const sourceAssetRefs = sourceMaterial.assetRefs;
-    if (materialComponent && Array.isArray(sourceAssetRefs)) {
-      materialComponent.assetRefs = sourceAssetRefs;
-    }
-  }
-  const sourceMeshGeometry = asRecord(values.meshGeometryValues.get(sourceEntityId));
-  if (sourceMeshGeometry) {
-    const meshGeometryComponent = world.getComponent(
-      targetEntityId,
-      MeshGeometryComponent
-    );
-    if (meshGeometryComponent) {
-      const parameters = asRecord(sourceMeshGeometry.parameters);
-      if (parameters) {
-        meshGeometryComponent.parameters = parameters;
-      }
-      if (typeof sourceMeshGeometry.modelName === "string") {
-        meshGeometryComponent.modelName = sourceMeshGeometry.modelName;
-      }
-      if (typeof sourceMeshGeometry.castShadow === "boolean") {
-        meshGeometryComponent.castShadow = sourceMeshGeometry.castShadow;
-      }
-      if (typeof sourceMeshGeometry.receiveShadow === "boolean") {
-        meshGeometryComponent.receiveShadow = sourceMeshGeometry.receiveShadow;
-      }
-    }
-  }
-  const sourceSelectable = asRecord(values.selectableValues.get(sourceEntityId));
-  if (sourceSelectable) {
-    const enabled = readBoolean(sourceSelectable.enabled);
-    let selectable = world.getComponent(targetEntityId, Selectable);
-    if (!selectable) {
-      objectManagementSystem.createComponentNow(
-        "selectable",
-        world,
-        targetEntityId,
-        enabled ?? true
-      );
-      selectable = world.getComponent(targetEntityId, Selectable);
-    }
-    if (selectable && typeof enabled === "boolean") {
-      selectable.enabled = enabled;
-    }
-  }
-  const sourcePhysics = asRecord(values.physicsValues.get(sourceEntityId));
-  if (sourcePhysics) {
-    const physicsValues = asRecord(sourcePhysics.values) ?? sourcePhysics;
-    let physics = world.getComponent(targetEntityId, PhysicsComponent);
-    if (!physics) {
-      objectManagementSystem.createComponentNow(
-        "physics",
-        world,
-        targetEntityId,
-        physicsValues
-      );
-      physics = world.getComponent(targetEntityId, PhysicsComponent);
-    }
-    if (physics) {
-      physics.setValues({
-        rigidbody: asRecord(physicsValues.rigidbody) ?? {},
-        collider: asRecord(physicsValues.collider) ?? {}
-      });
-    }
-  }
-  const sourceAnimation = asRecord(values.animationValues.get(sourceEntityId));
-  if (sourceAnimation) {
-    restoreAnimationComponent(
-      world,
-      objectManagementSystem,
-      targetEntityId,
-      sourceAnimation
-    );
-  }
-  const sourceInstancedMesh = asRecord(values.instancedMeshValues.get(sourceEntityId));
-  if (sourceInstancedMesh) {
-    const imComponent = world.getComponent(targetEntityId, InstancedMeshComponent);
-    if (imComponent) {
-      if (typeof sourceInstancedMesh.meshKind === "string") {
-        imComponent.meshKind = sourceInstancedMesh.meshKind;
-      }
-      if (typeof sourceInstancedMesh.modelPath === "string") {
-        imComponent.modelPath = sourceInstancedMesh.modelPath;
-      }
-      const parameters = asRecord(sourceInstancedMesh.meshParameters);
-      if (parameters) {
-        imComponent.meshParameters = parameters;
-      }
-      if (typeof sourceInstancedMesh.castShadow === "boolean") {
-        imComponent.castShadow = sourceInstancedMesh.castShadow;
-      }
-      if (typeof sourceInstancedMesh.receiveShadow === "boolean") {
-        imComponent.receiveShadow = sourceInstancedMesh.receiveShadow;
-      }
-      if (Array.isArray(sourceInstancedMesh.instanceEntityIds)) {
-        imComponent.instanceEntityIds = sourceInstancedMesh.instanceEntityIds;
-      }
-      imComponent.instancedMesh = null;
-    }
-  }
-  const sourceInstanceSlot = asRecord(values.instanceSlotValues.get(sourceEntityId));
-  if (sourceInstanceSlot) {
-    const slotComponent = world.getComponent(targetEntityId, InstanceSlotComponent);
-    if (slotComponent) {
-      if (typeof sourceInstanceSlot.slotIndex === "number") {
-        slotComponent.slotIndex = sourceInstanceSlot.slotIndex;
-      }
-    }
-  }
-  const sourcePrefabNode = asRecord(values.prefabNodeValues.get(sourceEntityId));
-  if (sourcePrefabNode && typeof sourcePrefabNode.nodeId === "string") {
-    if (!world.getComponent(targetEntityId, PrefabNode)) {
-      world.addComponent(targetEntityId, new PrefabNode(sourcePrefabNode.nodeId));
-    }
-  }
-  const sourcePrefabInstance = asRecord(
-    values.prefabInstanceValues.get(sourceEntityId)
-  );
-  if (sourcePrefabInstance && typeof sourcePrefabInstance.url === "string") {
-    if (!world.getComponent(targetEntityId, PrefabInstance)) {
-      const overrides = Array.isArray(sourcePrefabInstance.overrides) ? sourcePrefabInstance.overrides.filter(
-        (entry) => typeof entry === "string"
-      ) : [];
-      world.addComponent(
-        targetEntityId,
-        new PrefabInstance(
-          sourcePrefabInstance.url,
-          overrides,
-          // Preserve the placement identity; the constructor generates a
-          // fresh one for legacy snapshots that predate instanceId.
-          typeof sourcePrefabInstance.instanceId === "string" && sourcePrefabInstance.instanceId.length > 0 ? sourcePrefabInstance.instanceId : void 0
-        )
-      );
-    }
-  }
-}
-__name(restoreComponentState, "restoreComponentState");
-
-// core/hydration/types.ts
-var HYDRATABLE_ENTITY_KINDS = /* @__PURE__ */ new Set([
-  "cube",
-  "sphere",
-  "plane",
-  "capsule",
-  "cylinder",
-  "empty",
-  "model",
-  "image",
-  "imageTarget",
-  "sprite",
-  "audio",
-  "camera",
-  "video",
-  "ambientLight",
-  "directionalLight",
-  "pointLight",
-  "spotLight",
-  "areaLight",
-  "instancedMesh",
-  "instanceSlot",
-  "scriptObject",
-  "xrRig",
-  "xrInteractor",
-  "teleportArea",
-  "uiPanel",
-  "uiText",
-  "uiButton",
-  "uiToggle",
-  "uiSlider"
-]);
-
-// core/hydration/hydrateWorld.ts
-function buildEntityCreationPayload(sourceEntityId, kind, componentValues) {
-  const payload = {
-    name: readString(componentValues.nameValues.get(sourceEntityId)) ?? void 0,
-    transform: readTransform(componentValues.transformValues.get(sourceEntityId))
-  };
-  if (kind === "model") {
-    const model = asRecord(componentValues.modelValues.get(sourceEntityId));
-    if (typeof model?.path === "string") {
-      payload.path = model.path;
-    }
-  }
-  if (kind === "image") {
-    const image = asRecord(componentValues.imageValues.get(sourceEntityId));
-    if (typeof image?.path === "string") {
-      payload.path = image.path;
-    }
-  }
-  if (kind === "sprite") {
-    const sprite = asRecord(componentValues.spriteValues.get(sourceEntityId));
-    if (typeof sprite?.path === "string") {
-      payload.path = sprite.path;
-    }
-  }
-  if (kind === "video") {
-    const video = asRecord(componentValues.videoValues.get(sourceEntityId));
-    if (typeof video?.path === "string") {
-      payload.path = video.path;
-    }
-    const videoOptions = asRecord(video?.options);
-    if (videoOptions) {
-      payload.options = videoOptions;
-    }
-  }
-  if (kind === "audio") {
-    const audio = asRecord(componentValues.audioValues.get(sourceEntityId));
-    if (typeof audio?.path === "string") {
-      payload.path = audio.path;
-    }
-    const audioOptions = asRecord(audio?.options);
-    if (audioOptions) {
-      payload.options = audioOptions;
-    }
-  }
-  if (kind === "camera") {
-    const camera = asRecord(componentValues.cameraValues.get(sourceEntityId));
-    if (camera) {
-      const projection = camera.projection === "orthographic" || camera.projection === "perspective" ? camera.projection : void 0;
-      const type = camera.type === "3d" || camera.type === "ar" ? camera.type : void 0;
-      payload.options = {
-        isDefault: typeof camera.isDefault === "boolean" ? camera.isDefault : void 0,
-        projection,
-        type,
-        fov: typeof camera.fov === "number" ? camera.fov : void 0,
-        near: typeof camera.near === "number" ? camera.near : void 0,
-        far: typeof camera.far === "number" ? camera.far : void 0,
-        left: typeof camera.left === "number" ? camera.left : void 0,
-        right: typeof camera.right === "number" ? camera.right : void 0,
-        top: typeof camera.top === "number" ? camera.top : void 0,
-        bottom: typeof camera.bottom === "number" ? camera.bottom : void 0,
-        zoom: typeof camera.zoom === "number" ? camera.zoom : void 0
-      };
-    }
-  }
-  if (kind === "imageTarget") {
-    const imageTarget = asRecord(componentValues.imageTargetValues.get(sourceEntityId));
-    if (imageTarget) {
-      payload.options = {
-        targets: Array.isArray(imageTarget.targets) ? imageTarget.targets : [],
-        compiledTargetUrl: typeof imageTarget.compiledTargetUrl === "string" ? imageTarget.compiledTargetUrl : void 0,
-        compiledTargetDir: typeof imageTarget.compiledTargetDir === "string" ? imageTarget.compiledTargetDir : void 0
-      };
-    }
-  }
-  if (kind === "instancedMesh") {
-    const im = asRecord(componentValues.instancedMeshValues.get(sourceEntityId));
-    if (im) {
-      payload.options = {
-        meshKind: typeof im.meshKind === "string" ? im.meshKind : "cube",
-        modelPath: typeof im.modelPath === "string" ? im.modelPath : void 0,
-        meshParameters: asRecord(im.meshParameters) ?? void 0,
-        castShadow: typeof im.castShadow === "boolean" ? im.castShadow : false,
-        receiveShadow: typeof im.receiveShadow === "boolean" ? im.receiveShadow : false,
-        // New format: signal the factory to skip child entity creation.
-        // Old format (instances[]): pass through for migration — factory will
-        // create slot entities from the legacy InstanceTransform array.
-        ...Array.isArray(im.instanceEntityIds) ? { instanceEntityIds: im.instanceEntityIds } : Array.isArray(im.instances) ? { instances: im.instances } : {}
-      };
-    }
-  }
-  if (kind === "instanceSlot") {
-    const slot = asRecord(componentValues.instanceSlotValues.get(sourceEntityId));
-    if (slot) {
-      payload.options = {
-        groupEntityId: typeof slot.groupEntityId === "number" ? slot.groupEntityId : -1,
-        slotIndex: typeof slot.slotIndex === "number" ? slot.slotIndex : 0
-      };
-    }
-  }
-  if (kind === "scriptObject") {
-    const so = asRecord(componentValues.scriptObjectValues.get(sourceEntityId));
-    if (so) {
-      payload.options = {
-        scriptUrl: typeof so.scriptUrl === "string" ? so.scriptUrl : null,
-        className: typeof so.className === "string" ? so.className : null,
-        enabled: typeof so.enabled === "boolean" ? so.enabled : true
-      };
-    }
-  }
-  return payload;
-}
-__name(buildEntityCreationPayload, "buildEntityCreationPayload");
-function resolvePrimaryCameraSourceEntityId(snapshot, componentValues, entityTypeValues) {
-  let firstCameraSourceEntityId = null;
-  for (const sourceEntityId of snapshot.entities) {
-    const entityType = readString(entityTypeValues.get(sourceEntityId));
-    if (entityType !== "camera") {
-      continue;
-    }
-    if (firstCameraSourceEntityId === null) {
-      firstCameraSourceEntityId = sourceEntityId;
-    }
-    const cameraValue = asRecord(componentValues.cameraValues.get(sourceEntityId));
-    if (cameraValue?.isDefault === true) {
-      return sourceEntityId;
-    }
-  }
-  return firstCameraSourceEntityId;
-}
-__name(resolvePrimaryCameraSourceEntityId, "resolvePrimaryCameraSourceEntityId");
-function applyLocalTransformsAfterHierarchyRestore(world, scopeEntityIds) {
-  const transformEntities = scopeEntityIds ? Array.from(scopeEntityIds) : world.query(TransformComponent, Object3DRef);
-  for (const entityId of transformEntities) {
-    const transform = world.getComponent(entityId, TransformComponent);
-    const object = world.getComponent(entityId, Object3DRef)?.object;
-    if (!transform || !object) {
-      continue;
-    }
-    applyTransform(object, transform);
-    object.updateMatrixWorld(true);
-  }
-}
-__name(applyLocalTransformsAfterHierarchyRestore, "applyLocalTransformsAfterHierarchyRestore");
-function hydrateWorldFromSnapshotDetailed(snapshot, world, objectManagementSystem, options) {
-  if (!snapshot || !snapshot.entities.length) {
-    return {
-      restoredCount: 0,
-      selectedEntityId: null,
-      idMap: /* @__PURE__ */ new Map()
-    };
-  }
-  const assignPrimaryCamera = options?.assignPrimaryCamera !== false;
-  const entityTypeValues = readByComponent(snapshot.components, "EntityType");
-  const componentValues = buildComponentValueMaps(snapshot);
-  const primaryCameraSourceEntityId = assignPrimaryCamera ? resolvePrimaryCameraSourceEntityId(
-    snapshot,
-    componentValues,
-    entityTypeValues
-  ) : null;
-  const idMap = /* @__PURE__ */ new Map();
-  for (const sourceEntityId of snapshot.entities) {
-    const entityTypeValue = entityTypeValues.get(sourceEntityId);
-    const entityType = readString(entityTypeValue);
-    if (!entityType || !HYDRATABLE_ENTITY_KINDS.has(entityType)) {
-      continue;
-    }
-    const kind = entityType;
-    const payload = buildEntityCreationPayload(sourceEntityId, kind, componentValues);
-    if (kind === "camera" && sourceEntityId === primaryCameraSourceEntityId) {
-      payload.useWorldCamera = true;
-      const options2 = asRecord(payload.options);
-      payload.options = {
-        ...options2 ?? {},
-        isDefault: true
-      };
-    }
-    payload.skipDefaultChildren = true;
-    const createdEntityId = objectManagementSystem.createNow(kind, world, payload);
-    idMap.set(sourceEntityId, createdEntityId);
-  }
-  for (const sourceEntityId of snapshot.entities) {
-    const targetEntityId = idMap.get(sourceEntityId);
-    if (targetEntityId === void 0) {
-      continue;
-    }
-    const entityType = readString(entityTypeValues.get(sourceEntityId));
-    restoreComponentState(
-      world,
-      objectManagementSystem,
-      targetEntityId,
-      sourceEntityId,
-      entityType,
-      componentValues
-    );
-    restorePostCreateComponents(
-      world,
-      objectManagementSystem,
-      targetEntityId,
-      sourceEntityId,
-      entityType,
-      componentValues,
-      idMap
-    );
-  }
-  applyParentLinks(snapshot, idMap, objectManagementSystem, world);
-  objectManagementSystem.reconcileSceneFromWorld(world);
-  applyLocalTransformsAfterHierarchyRestore(
-    world,
-    options?.applyTransformsScope === "created" ? idMap.values() : void 0
-  );
-  const selectedEntityId = typeof snapshot.selectedEntityId === "number" ? idMap.get(snapshot.selectedEntityId) ?? null : null;
-  return {
-    restoredCount: idMap.size,
-    selectedEntityId,
-    idMap
-  };
-}
-__name(hydrateWorldFromSnapshotDetailed, "hydrateWorldFromSnapshotDetailed");
-function hydrateWorldFromSnapshot(snapshot, world, objectManagementSystem) {
-  return hydrateWorldFromSnapshotDetailed(
-    snapshot,
-    world,
-    objectManagementSystem
-  ).restoredCount;
-}
-__name(hydrateWorldFromSnapshot, "hydrateWorldFromSnapshot");
-
-// core/prefab/nodeKeys.ts
-var NODE_KEY_SEPARATOR = "/";
-var ADDED_NODE_MARKER_COMPONENT = "+node";
-var asRecord2 = /* @__PURE__ */ __name((value) => value !== null && typeof value === "object" && !Array.isArray(value) ? value : null, "asRecord");
-var readBlock = /* @__PURE__ */ __name((snapshot, component) => {
-  const map = /* @__PURE__ */ new Map();
-  const block = snapshot.components.find((b) => b.component === component);
-  for (const entry of block?.entries ?? []) {
-    const record = asRecord2(entry.value);
-    if (record) {
-      map.set(entry.entityId, record);
-    }
-  }
-  return map;
-}, "readBlock");
-var fallbackInstanceId = /* @__PURE__ */ __name((entityId) => `e${entityId}`, "fallbackInstanceId");
-function buildNodeKeyMapsFromSnapshot(snapshot, options) {
-  const parentValues = readBlock(snapshot, "ParentId");
-  const nodeValues = readBlock(snapshot, "PrefabNode");
-  const instanceValues = readBlock(snapshot, "PrefabInstance");
-  const inDocument = new Set(snapshot.entities);
-  const childrenByParent = /* @__PURE__ */ new Map();
-  const rootIds = [];
-  for (const entityId of snapshot.entities) {
-    const parent = parentValues.get(entityId)?.value;
-    if (typeof parent === "number" && inDocument.has(parent)) {
-      const siblings = childrenByParent.get(parent);
-      if (siblings) siblings.push(entityId);
-      else childrenByParent.set(parent, [entityId]);
-    } else {
-      rootIds.push(entityId);
-    }
-  }
-  const scopeRoots = options?.scopeRootEntityId !== void 0 ? [options.scopeRootEntityId] : rootIds;
-  const idToKey = /* @__PURE__ */ new Map();
-  const keyToId = /* @__PURE__ */ new Map();
-  const boundaryIds = /* @__PURE__ */ new Map();
-  const scopeRootSet = new Set(scopeRoots);
-  const queue = scopeRoots.map(
-    (entityId) => ({ entityId, prefix: "" })
-  );
-  while (queue.length > 0) {
-    const { entityId, prefix } = queue.shift();
-    const instance = instanceValues.get(entityId);
-    const isBoundary = Boolean(
-      instance && typeof instance.url === "string" && !scopeRootSet.has(entityId)
-    );
-    let ownPrefix = prefix;
-    let childPrefix = prefix;
-    if (isBoundary && instance) {
-      const instanceId = typeof instance.instanceId === "string" && instance.instanceId.length > 0 ? instance.instanceId : fallbackInstanceId(entityId);
-      childPrefix = `${prefix}${instanceId}${NODE_KEY_SEPARATOR}`;
-      ownPrefix = childPrefix;
-      boundaryIds.set(entityId, {
-        url: instance.url,
-        instanceId
-      });
-    }
-    const nodeId = nodeValues.get(entityId)?.nodeId;
-    if (typeof nodeId === "string" && nodeId.length > 0) {
-      const key = `${ownPrefix}${nodeId}`;
-      idToKey.set(entityId, key);
-      keyToId.set(key, entityId);
-    }
-    for (const child of childrenByParent.get(entityId) ?? []) {
-      queue.push({ entityId: child, prefix: childPrefix });
-    }
-  }
-  const rootEntityId = scopeRoots[0];
-  const rootNodeId = rootEntityId !== void 0 ? nodeValues.get(rootEntityId)?.nodeId : void 0;
-  return {
-    idToKey,
-    keyToId,
-    rootKey: typeof rootNodeId === "string" && rootNodeId.length > 0 ? rootNodeId : null,
-    boundaryIds
-  };
-}
-__name(buildNodeKeyMapsFromSnapshot, "buildNodeKeyMapsFromSnapshot");
-function collectSnapshotSubtreeIds(snapshot, rootEntityId) {
-  const parentValues = readBlock(snapshot, "ParentId");
-  const childrenByParent = /* @__PURE__ */ new Map();
-  for (const entityId of snapshot.entities) {
-    const parent = parentValues.get(entityId)?.value;
-    if (typeof parent === "number") {
-      const siblings = childrenByParent.get(parent);
-      if (siblings) siblings.push(entityId);
-      else childrenByParent.set(parent, [entityId]);
-    }
-  }
-  const ordered = [];
-  const seen = /* @__PURE__ */ new Set();
-  const queue = [rootEntityId];
-  while (queue.length > 0) {
-    const entityId = queue.shift();
-    if (seen.has(entityId)) continue;
-    seen.add(entityId);
-    ordered.push(entityId);
-    queue.push(...childrenByParent.get(entityId) ?? []);
-  }
-  return ordered;
-}
-__name(collectSnapshotSubtreeIds, "collectSnapshotSubtreeIds");
-function findTopLevelNestedRegions(snapshot) {
-  const parentValues = readBlock(snapshot, "ParentId");
-  const instanceValues = readBlock(snapshot, "PrefabInstance");
-  const inDocument = new Set(snapshot.entities);
-  const roots = new Set(
-    snapshot.entities.filter((entityId) => {
-      const parent = parentValues.get(entityId)?.value;
-      return typeof parent !== "number" || !inDocument.has(parent);
-    })
-  );
-  const regions = [];
-  for (const [entityId, instance] of instanceValues) {
-    if (roots.has(entityId)) continue;
-    if (typeof instance.url !== "string" || instance.url.length === 0) continue;
-    let ancestor = parentValues.get(entityId)?.value;
-    let nestedDeeper = false;
-    let hops = 0;
-    while (typeof ancestor === "number" && hops < 512) {
-      if (instanceValues.has(ancestor) && !roots.has(ancestor)) {
-        nestedDeeper = true;
-        break;
-      }
-      ancestor = parentValues.get(ancestor)?.value;
-      hops += 1;
-    }
-    if (nestedDeeper) continue;
-    regions.push({
-      rootEntityId: entityId,
-      url: instance.url,
-      instanceId: typeof instance.instanceId === "string" && instance.instanceId.length > 0 ? instance.instanceId : fallbackInstanceId(entityId),
-      overrides: Array.isArray(instance.overrides) ? instance.overrides.filter(
-        (entry) => typeof entry === "string"
-      ) : []
-    });
-  }
-  regions.sort((a, b) => a.rootEntityId - b.rootEntityId);
-  return regions;
-}
-__name(findTopLevelNestedRegions, "findTopLevelNestedRegions");
-
-// core/prefab/overrides.ts
-var OVERRIDE_DIFF_EXCLUDED_COMPONENTS = /* @__PURE__ */ new Set([
-  "PrefabNode",
-  "PrefabInstance",
-  "EntityType",
-  "Selectable",
-  "SelectionTransformState"
-]);
-var OVERRIDE_ROOT_EXCLUDED_COMPONENTS = /* @__PURE__ */ new Set([
-  "TransformComponent",
-  "Name",
-  "ParentId"
-]);
-var asRecord3 = /* @__PURE__ */ __name((value) => value !== null && typeof value === "object" && !Array.isArray(value) ? value : null, "asRecord");
-var clone = /* @__PURE__ */ __name((value) => value === void 0 ? value : structuredClone(value), "clone");
-var isNodeRef = /* @__PURE__ */ __name((value) => {
-  const record = asRecord3(value);
-  return Boolean(
-    record && typeof record.$node === "string" && Object.keys(record).length === 1
-  );
-}, "isNodeRef");
-var makeNodeRef = /* @__PURE__ */ __name((nodeId) => ({ $node: nodeId }), "makeNodeRef");
-function findSnapshotRootEntityIds(snapshot) {
-  const parentBlock = snapshot.components.find(
-    (block) => block.component === "ParentId"
-  );
-  const parentByEntity = /* @__PURE__ */ new Map();
-  for (const entry of parentBlock?.entries ?? []) {
-    parentByEntity.set(entry.entityId, asRecord3(entry.value)?.value ?? null);
-  }
-  return snapshot.entities.filter(
-    (entityId) => typeof parentByEntity.get(entityId) !== "number"
-  );
-}
-__name(findSnapshotRootEntityIds, "findSnapshotRootEntityIds");
-function buildNodeMapsFromSnapshot(snapshot) {
-  const idToNode = /* @__PURE__ */ new Map();
-  const nodeToId = /* @__PURE__ */ new Map();
-  const nodeBlock = snapshot.components.find(
-    (block) => block.component === "PrefabNode"
-  );
-  for (const entry of nodeBlock?.entries ?? []) {
-    const nodeId = asRecord3(entry.value)?.nodeId;
-    if (typeof nodeId === "string" && nodeId.length > 0) {
-      idToNode.set(entry.entityId, nodeId);
-      nodeToId.set(nodeId, entry.entityId);
-    }
-  }
-  const rootEntityId = findSnapshotRootEntityIds(snapshot)[0];
-  const rootNodeId = rootEntityId !== void 0 ? idToNode.get(rootEntityId) ?? null : null;
-  return { idToNode, nodeToId, rootNodeId };
-}
-__name(buildNodeMapsFromSnapshot, "buildNodeMapsFromSnapshot");
-function indexSnapshotByEntity(snapshot) {
-  const byEntity = /* @__PURE__ */ new Map();
-  for (const block of snapshot.components) {
-    for (const entry of block.entries) {
-      let componentMap = byEntity.get(entry.entityId);
-      if (!componentMap) {
-        componentMap = /* @__PURE__ */ new Map();
-        byEntity.set(entry.entityId, componentMap);
-      }
-      componentMap.set(block.component, entry.value);
-    }
-  }
-  return byEntity;
-}
-__name(indexSnapshotByEntity, "indexSnapshotByEntity");
-var toRefOrRaw = /* @__PURE__ */ __name((id, idToNode) => {
-  const nodeId = idToNode.get(id);
-  return nodeId !== void 0 ? makeNodeRef(nodeId) : id;
-}, "toRefOrRaw");
-function canonicalizeScriptDataFields(data, idToNode) {
-  const canonicalData = {};
-  for (const [key, fieldValue] of Object.entries(data)) {
-    const field = asRecord3(fieldValue);
-    if (field?.type === "entity" && typeof field.value === "number") {
-      canonicalData[key] = {
-        ...field,
-        value: toRefOrRaw(field.value, idToNode)
-      };
-      continue;
-    }
-    const componentRef = asRecord3(field?.value);
-    if (field?.type === "component" && componentRef && typeof componentRef.entityId === "number") {
-      canonicalData[key] = {
-        ...field,
-        value: {
-          ...componentRef,
-          entityId: toRefOrRaw(componentRef.entityId, idToNode)
-        }
-      };
-      continue;
-    }
-    canonicalData[key] = fieldValue;
-  }
-  return canonicalData;
-}
-__name(canonicalizeScriptDataFields, "canonicalizeScriptDataFields");
-function canonicalizeComponentValue(componentName, value, idToNode) {
-  const cloned = clone(value);
-  const record = asRecord3(cloned);
-  if (!record) {
-    return cloned;
-  }
-  if (componentName === "ParentId") {
-    if (typeof record.value === "number") {
-      record.value = toRefOrRaw(record.value, idToNode);
-    }
-    return record;
-  }
-  if (componentName === "Object3DRef") {
-    return {
-      visibility: typeof record.visibility === "boolean" ? record.visibility : true
-    };
-  }
-  if (componentName === "ScriptComponent") {
-    const entries = Array.isArray(record.entries) ? record.entries : [];
-    return {
-      entries: entries.map((rawEntry) => {
-        const entry = asRecord3(rawEntry);
-        if (!entry) {
-          return rawEntry;
-        }
-        return {
-          className: typeof entry.className === "string" ? entry.className : "",
-          scriptUrl: typeof entry.scriptUrl === "string" ? entry.scriptUrl : "",
-          enabled: typeof entry.enabled === "boolean" ? entry.enabled : true,
-          data: canonicalizeScriptDataFields(asRecord3(entry.data) ?? {}, idToNode)
-        };
-      })
-    };
-  }
-  if (componentName === "ScriptObjectComponent") {
-    return {
-      scriptUrl: typeof record.scriptUrl === "string" ? record.scriptUrl : null,
-      className: typeof record.className === "string" ? record.className : null,
-      enabled: typeof record.enabled === "boolean" ? record.enabled : true,
-      data: canonicalizeScriptDataFields(asRecord3(record.data) ?? {}, idToNode)
-    };
-  }
-  if (componentName === "InstancedMeshComponent") {
-    if (Array.isArray(record.instanceEntityIds)) {
-      record.instanceEntityIds = record.instanceEntityIds.map(
-        (id) => typeof id === "number" ? toRefOrRaw(id, idToNode) : id
-      );
-    }
-    return record;
-  }
-  if (componentName === "InstanceSlotComponent") {
-    if (typeof record.groupEntityId === "number" && record.groupEntityId !== -1) {
-      record.groupEntityId = toRefOrRaw(record.groupEntityId, idToNode);
-    }
-    return record;
-  }
-  return record;
-}
-__name(canonicalizeComponentValue, "canonicalizeComponentValue");
-function decanonicalizeComponentValue(value, nodeToId) {
-  if (isNodeRef(value)) {
-    return nodeToId.get(value.$node) ?? null;
-  }
-  if (Array.isArray(value)) {
-    return value.map((item) => decanonicalizeComponentValue(item, nodeToId));
-  }
-  const record = asRecord3(value);
-  if (record) {
-    const result = {};
-    for (const [key, item] of Object.entries(record)) {
-      result[key] = decanonicalizeComponentValue(item, nodeToId);
-    }
-    return result;
-  }
-  return value;
-}
-__name(decanonicalizeComponentValue, "decanonicalizeComponentValue");
-var encodeOverride = /* @__PURE__ */ __name((nodeId, componentName, path) => `${nodeId}|${componentName}|${path}`, "encodeOverride");
-function parseOverride(encoded) {
-  const firstSep = encoded.indexOf("|");
-  if (firstSep <= 0) {
-    return null;
-  }
-  const secondSep = encoded.indexOf("|", firstSep + 1);
-  if (secondSep <= firstSep + 1) {
-    return null;
-  }
-  return {
-    nodeId: encoded.slice(0, firstSep),
-    componentName: encoded.slice(firstSep + 1, secondSep),
-    path: encoded.slice(secondSep + 1)
-  };
-}
-__name(parseOverride, "parseOverride");
-function groupOverridePaths(overrides) {
-  const grouped = /* @__PURE__ */ new Map();
-  for (const encoded of overrides) {
-    const parsed = parseOverride(encoded);
-    if (!parsed) {
-      continue;
-    }
-    let byComponent = grouped.get(parsed.nodeId);
-    if (!byComponent) {
-      byComponent = /* @__PURE__ */ new Map();
-      grouped.set(parsed.nodeId, byComponent);
-    }
-    let paths = byComponent.get(parsed.componentName);
-    if (!paths) {
-      paths = /* @__PURE__ */ new Set();
-      byComponent.set(parsed.componentName, paths);
-    }
-    paths.add(parsed.path);
-  }
-  return grouped;
-}
-__name(groupOverridePaths, "groupOverridePaths");
-var isPrimitive = /* @__PURE__ */ __name((value) => value === null || typeof value !== "object", "isPrimitive");
-function collectDiffPaths(base, current, prefix = "", out = []) {
-  if (isNodeRef(base) || isNodeRef(current)) {
-    const same = isNodeRef(base) && isNodeRef(current) && base.$node === current.$node;
-    if (!same) {
-      out.push(prefix);
-    }
-    return out;
-  }
-  if (isPrimitive(base) || isPrimitive(current)) {
-    if (base !== current) {
-      out.push(prefix);
-    }
-    return out;
-  }
-  const baseIsArray = Array.isArray(base);
-  const currentIsArray = Array.isArray(current);
-  if (baseIsArray !== currentIsArray) {
-    out.push(prefix);
-    return out;
-  }
-  if (baseIsArray && currentIsArray) {
-    if (base.length !== current.length) {
-      out.push(prefix);
-      return out;
-    }
-    base.forEach((item, index) => {
-      collectDiffPaths(
-        item,
-        current[index],
-        prefix ? `${prefix}/${index}` : String(index),
-        out
-      );
-    });
-    return out;
-  }
-  const baseRecord = base;
-  const currentRecord = current;
-  const keys = /* @__PURE__ */ new Set([
-    ...Object.keys(baseRecord),
-    ...Object.keys(currentRecord)
-  ]);
-  for (const key of keys) {
-    const childPrefix = prefix ? `${prefix}/${key}` : key;
-    if (!(key in baseRecord) || !(key in currentRecord)) {
-      out.push(childPrefix);
-      continue;
-    }
-    collectDiffPaths(baseRecord[key], currentRecord[key], childPrefix, out);
-  }
-  return out;
-}
-__name(collectDiffPaths, "collectDiffPaths");
-function computeInstanceOverrides(baseSnapshot, instanceSnapshot, options) {
-  const baseMaps = buildNodeKeyMapsFromSnapshot(baseSnapshot);
-  const instanceMaps = buildNodeKeyMapsFromSnapshot(instanceSnapshot);
-  const baseByEntity = indexSnapshotByEntity(baseSnapshot);
-  const instanceByEntity = indexSnapshotByEntity(instanceSnapshot);
-  const overrides = [];
-  for (const [nodeKey, instanceEntityId] of instanceMaps.keyToId) {
-    const baseEntityId = baseMaps.keyToId.get(nodeKey);
-    if (baseEntityId === void 0) {
-      if (options?.emitAdditionMarkers) {
-        overrides.push(
-          encodeOverride(nodeKey, ADDED_NODE_MARKER_COMPONENT, "")
-        );
-      }
-      continue;
-    }
-    const baseComponents = baseByEntity.get(baseEntityId);
-    const instanceComponents = instanceByEntity.get(instanceEntityId);
-    if (!baseComponents) {
-      continue;
-    }
-    const isRoot = nodeKey === baseMaps.rootKey;
-    for (const [componentName, baseRaw] of baseComponents) {
-      if (OVERRIDE_DIFF_EXCLUDED_COMPONENTS.has(componentName)) {
-        continue;
-      }
-      if (isRoot && OVERRIDE_ROOT_EXCLUDED_COMPONENTS.has(componentName)) {
-        continue;
-      }
-      const instanceRaw = instanceComponents?.get(componentName);
-      if (instanceRaw === void 0) {
-        continue;
-      }
-      const baseCanonical = canonicalizeComponentValue(
-        componentName,
-        baseRaw,
-        baseMaps.idToKey
-      );
-      const instanceCanonical = canonicalizeComponentValue(
-        componentName,
-        instanceRaw,
-        instanceMaps.idToKey
-      );
-      for (const path of collectDiffPaths(baseCanonical, instanceCanonical)) {
-        overrides.push(encodeOverride(nodeKey, componentName, path));
-      }
-    }
-  }
-  return overrides;
-}
-__name(computeInstanceOverrides, "computeInstanceOverrides");
-var PATH_TOKEN_SPLIT = "/";
-function getAtPath(value, tokens) {
-  let cursor = value;
-  for (const token of tokens) {
-    if (Array.isArray(cursor)) {
-      cursor = cursor[Number(token)];
-    } else {
-      const record = asRecord3(cursor);
-      if (!record) {
-        return void 0;
-      }
-      cursor = record[token];
-    }
-    if (cursor === void 0) {
-      return void 0;
-    }
-  }
-  return cursor;
-}
-__name(getAtPath, "getAtPath");
-function setAtPath(target, tokens, value) {
-  let cursor = target;
-  for (let i = 0; i < tokens.length - 1; i++) {
-    const token = tokens[i];
-    if (Array.isArray(cursor)) {
-      cursor = cursor[Number(token)];
-    } else {
-      const record = asRecord3(cursor);
-      if (!record) {
-        return;
-      }
-      cursor = record[token];
-    }
-    if (cursor === null || typeof cursor !== "object") {
-      return;
-    }
-  }
-  const last = tokens[tokens.length - 1];
-  if (Array.isArray(cursor)) {
-    cursor[Number(last)] = value;
-  } else {
-    const record = asRecord3(cursor);
-    if (record) {
-      if (value === void 0) {
-        delete record[last];
-      } else {
-        record[last] = value;
-      }
-    }
-  }
-}
-__name(setAtPath, "setAtPath");
-function mergeComponentValue(newFileCanonical, instanceCanonical, overridePaths) {
-  if (!overridePaths || overridePaths.size === 0) {
-    return clone(newFileCanonical);
-  }
-  if (overridePaths.has("")) {
-    return clone(instanceCanonical);
-  }
-  const merged = clone(newFileCanonical);
-  for (const path of overridePaths) {
-    const tokens = path.split(PATH_TOKEN_SPLIT);
-    const instanceValue = getAtPath(instanceCanonical, tokens);
-    setAtPath(merged, tokens, clone(instanceValue));
-  }
-  return merged;
-}
-__name(mergeComponentValue, "mergeComponentValue");
-
-// core/prefab/instantiateSubtree.ts
-var INSTANTIATE_EXCLUDED_COMPONENTS = /* @__PURE__ */ new Set([
-  "Environment",
-  "Postprocessing",
-  "SelectionTransformState"
-]);
-function instantiateSubtree(world, objectManagementSystem, snapshot) {
-  const snapshotRootIds = new Set(findSnapshotRootEntityIds(snapshot));
-  const safeSnapshot = {
-    entities: snapshot.entities,
-    components: snapshot.components.filter((block) => !INSTANTIATE_EXCLUDED_COMPONENTS.has(block.component)).map(
-      (block) => block.component === "PrefabInstance" ? {
-        component: block.component,
-        entries: block.entries.filter(
-          (entry) => !snapshotRootIds.has(entry.entityId)
-        )
-      } : block
-    ).filter((block) => block.entries.length > 0)
-  };
-  const result = hydrateWorldFromSnapshotDetailed(
-    safeSnapshot,
-    world,
-    objectManagementSystem,
-    { assignPrimaryCamera: false, applyTransformsScope: "created" }
-  );
-  const rootSourceId = findSnapshotRootEntityIds(safeSnapshot).find(
-    (sourceId) => result.idMap.has(sourceId)
-  );
-  return {
-    rootId: rootSourceId !== void 0 ? result.idMap.get(rootSourceId) ?? null : null,
-    idMap: result.idMap
-  };
-}
-__name(instantiateSubtree, "instantiateSubtree");
-
-// core/prefab/types.ts
-var PREFAB_FILE_VERSION = 1;
-var PREFAB_FILE_VERSION_NESTED = 2;
-function prefabFileVersionFor(snapshot) {
-  return findTopLevelNestedRegions(snapshot).length > 0 ? PREFAB_FILE_VERSION_NESTED : PREFAB_FILE_VERSION;
-}
-__name(prefabFileVersionFor, "prefabFileVersionFor");
-var isRecord = /* @__PURE__ */ __name((value) => value !== null && typeof value === "object" && !Array.isArray(value), "isRecord");
-function parsePrefabAsset(json) {
-  if (!isRecord(json)) {
-    return null;
-  }
-  if (typeof json.version !== "number" || json.version < 1) {
-    return null;
-  }
-  const snapshot = json.snapshot;
-  if (!isRecord(snapshot)) {
-    return null;
-  }
-  const entities = snapshot.entities;
-  const components = snapshot.components;
-  if (!Array.isArray(entities) || !Array.isArray(components)) {
-    return null;
-  }
-  if (!entities.every((id) => typeof id === "number")) {
-    return null;
-  }
-  if (!components.every(
-    (block) => isRecord(block) && typeof block.component === "string" && Array.isArray(block.entries)
-  )) {
-    return null;
-  }
-  return {
-    version: json.version,
-    type: json.type === "scene" ? "scene" : "prefab",
-    name: typeof json.name === "string" ? json.name : void 0,
-    snapshot
-  };
-}
-__name(parsePrefabAsset, "parsePrefabAsset");
-
-// core/prefab/spawnPrefab.ts
-var prefabAssetUrlResolver = null;
-function setPrefabAssetUrlResolver(resolver) {
-  prefabAssetUrlResolver = resolver;
-}
-__name(setPrefabAssetUrlResolver, "setPrefabAssetUrlResolver");
-var resolveUrl = /* @__PURE__ */ __name((url) => prefabAssetUrlResolver ? prefabAssetUrlResolver(url) : url, "resolveUrl");
-function transformStringsDeep(value, fn) {
-  if (typeof value === "string") {
-    return fn(value);
-  }
-  if (Array.isArray(value)) {
-    return value.map((item) => transformStringsDeep(item, fn));
-  }
-  if (value !== null && typeof value === "object") {
-    const result = {};
-    for (const [key, item] of Object.entries(value)) {
-      result[key] = transformStringsDeep(item, fn);
-    }
-    return result;
-  }
-  return value;
-}
-__name(transformStringsDeep, "transformStringsDeep");
-var prefabCache = /* @__PURE__ */ new Map();
-function loadPrefab(url) {
-  const cached = prefabCache.get(url);
-  if (cached) {
-    return cached;
-  }
-  const pending = (async () => {
-    const response = await fetch(resolveUrl(url));
-    if (!response.ok) {
-      throw new Error(`Failed to fetch prefab "${url}" (${response.status})`);
-    }
-    const json = await response.json();
-    const parsed = parsePrefabAsset(json);
-    if (!parsed) {
-      throw new Error(`Invalid prefab file at "${url}"`);
-    }
-    return {
-      ...parsed,
-      snapshot: transformStringsDeep(
-        parsed.snapshot,
-        resolveUrl
-      )
-    };
-  })();
-  prefabCache.set(url, pending);
-  pending.catch(() => {
-    if (prefabCache.get(url) === pending) {
-      prefabCache.delete(url);
-    }
-  });
-  return pending;
-}
-__name(loadPrefab, "loadPrefab");
-function clearPrefabCache(url) {
-  if (typeof url === "string") {
-    prefabCache.delete(url);
-  } else {
-    prefabCache.clear();
-  }
-}
-__name(clearPrefabCache, "clearPrefabCache");
-function resolveSource(source) {
-  if (typeof source === "string") {
-    return { url: source, asset: loadPrefab(source) };
-  }
-  if ("path" in source && typeof source.path === "string") {
-    return { url: source.path, asset: loadPrefab(source.path) };
-  }
-  const asset = source;
-  return { url: asset.name ?? "", asset };
-}
-__name(resolveSource, "resolveSource");
-async function spawnPrefab(world, source, options) {
-  const { url, asset } = resolveSource(source);
-  const prefab = await asset;
-  const objectManagementSystem = world.getObjectManagementSystem();
-  const { rootId } = instantiateSubtree(
-    world,
-    objectManagementSystem,
-    prefab.snapshot
-  );
-  if (rootId === null) {
-    throw new Error(
-      `Prefab "${url || prefab.name || "unknown"}" contained no spawnable entities`
-    );
-  }
-  if (!world.getComponent(rootId, PrefabInstance)) {
-    world.addComponent(rootId, new PrefabInstance(url, []));
-  }
-  if (options?.parentId !== void 0 && options.parentId !== null) {
-    objectManagementSystem.setParent(world, rootId, options.parentId, {
-      preserveWorldTransform: false
-    });
-  }
-  const transform = world.getComponent(rootId, TransformComponent);
-  if (transform && (options?.position || options?.rotation || options?.scale)) {
-    const write = /* @__PURE__ */ __name((target, src) => {
-      if (!src) return;
-      if (typeof src.x === "number") target.x = src.x;
-      if (typeof src.y === "number") target.y = src.y;
-      if (typeof src.z === "number") target.z = src.z;
-    }, "write");
-    write(transform.position, options.position);
-    write(transform.rotation, options.rotation);
-    write(transform.scale, options.scale);
-    const object = world.getComponent(rootId, Object3DRef)?.object;
-    if (object) {
-      applyTransform(object, transform);
-      object.updateMatrixWorld(true);
-    }
-  }
-  return rootId;
-}
-__name(spawnPrefab, "spawnPrefab");
-function despawnPrefab(world, rootId, dispose = true) {
-  const objectManagementSystem = world.getObjectManagementSystem();
-  const subtree = collectEntitySubtree(world, [rootId]).reverse();
-  let removed = 0;
-  for (const entityId of subtree) {
-    if (objectManagementSystem.deleteEntity(world, entityId, dispose)) {
-      removed += 1;
-    }
-  }
-  return removed;
-}
-__name(despawnPrefab, "despawnPrefab");
-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) {
-  }
-  /**
-   * Instantiate a prefab asset into the world at runtime.
-   *
-   * `source` is typically an `AssetInput` field from this script's `data`
-   * (drag a `.prefab` from the asset browser onto the field in the editor),
-   * a URL string, or a pre-loaded `PrefabAsset`. Resolves with the new root
-   * entity id.
-   *
-   * ```ts
-   * data = { enemyPrefab: { path: "", type: "prefab" } };
-   * async onUpdate() {
-   *   if (shouldSpawn) {
-   *     const id = await this.spawnPrefab(this.data.enemyPrefab, {
-   *       position: { x: 0, y: 0, z: -5 },
-   *     });
-   *   }
-   * }
-   * ```
-   */
-  spawnPrefab(source, options) {
-    return spawnPrefab(this.world, source, options);
-  }
-  /**
-   * Remove a spawned prefab instance (the root entity and all descendants).
-   * Returns the number of entities removed.
-   */
-  despawn(rootEntityId) {
-    return despawnPrefab(this.world, rootEntityId);
-  }
-  /**
-   * 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 THREE19.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 THREE19.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 THREE19.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;
+          im.castShadow = comp.castShadow;
+          im.receiveShadow = comp.receiveShadow;
+        }
+      }
     }
-    const clone2 = this.threeRef.object.clone();
-    const rotation = new THREE19.Quaternion();
-    clone2.lookAt(targetPosition);
-    clone2.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);
+};
+__name(_InstancedMeshSystem, "InstancedMeshSystem");
+var InstancedMeshSystem = _InstancedMeshSystem;
+
+// core/systems/RenderSystem.ts
+var _RenderSystem = class _RenderSystem {
+  constructor(renderer, scene, camera, afterRender) {
+    /** Composer the last size was pushed to, plus that size. */
+    this.sizedComposer = null;
+    this.sizedWidth = 0;
+    this.sizedHeight = 0;
+    this.sizedPixelRatio = 0;
+    this.warnedUninitialized = false;
+    this.renderer = renderer;
+    this.scene = scene;
+    this.camera = camera;
+    this.afterRender = afterRender;
   }
   /**
-   * 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).
+   * `WebGPURenderer.render()` throws until `await renderer.init()` resolved.
+   * Skip those frames (warning once) rather than throwing from the loop.
    */
-  getParent() {
-    const parentIdComponent = this.getComponent(ParentId);
-    const parentEntityId = parentIdComponent?.value ?? null;
-    if (parentEntityId === null) {
-      return {
-        parentIdComponent,
-        parent: null
-      };
+  isRendererReady() {
+    const renderer = this.renderer;
+    if (renderer.isWebGPURenderer !== true || renderer.initialized !== false) {
+      return true;
     }
-    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
+    if (!this.warnedUninitialized) {
+      this.warnedUninitialized = true;
+      console.warn(
+        "[spatial-ecs] RenderSystem skipped a frame: the WebGPURenderer is not initialised yet. Call `await renderer.init()` before the first world.update()."
       );
-      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. Runs at preview/runtime only — never in the editor.
-   */
-  init() {
-  }
-  /**
-   * Called every frame while the script is enabled. Override with the
-   * script's main per-frame logic. Runs at preview/runtime only — never in the
-   * editor (use {@link ScriptObject} for editor-visible visuals).
-   */
-  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) {
-  }
-  // ─── WebXR (VR / MR) hooks ────────────────────────────────────────────────
-  // Dispatched by XRSessionSystem / XRInteractionSystem, following the same
-  // pattern as the AR hooks above: public no-op methods that subclasses opt
-  // into by overriding. They never fire outside an immersive session.
-  /**
-   * Called once when an immersive session starts. Optional XR hook.
-   *
-   * Use it to set up XR-only state. Inspect `capabilities` rather than guessing
-   * by device: feature support differs sharply per headset (for example Vision
-   * Pro grants no passthrough on the web today).
-   *
-   * @param capabilities - What the session actually granted, read from
-   *   `XRSession.enabledFeatures`.
-   */
-  onXRSessionStart(capabilities) {
-  }
-  /** Called once when the immersive session ends. Optional XR hook. */
-  onXRSessionEnd() {
-  }
-  /**
-   * Called when a primary action begins — controller trigger, hand pinch, or
-   * Vision Pro gaze-pinch. Optional XR hook.
-   *
-   * @param input - Normalized state for the source that acted.
-   */
-  onSelectStart(input) {
-  }
-  /** Called when the primary action ends. Optional XR hook. */
-  onSelectEnd(input) {
-  }
-  /**
-   * Called when this entity is grabbed. Optional XR hook.
-   *
-   * Only fires for entities carrying an enabled, grabbable
-   * `XRInteractableComponent`.
-   *
-   * @param input - The source doing the grabbing.
-   */
-  /**
-   * A SECOND hand joined a two-hand grab on this entity.
-   *
-   * The first hand anchors the object and keeps holding it; this fires for the
-   * hand that came second — the foregrip on a rifle, say.
-   */
-  onSecondaryGrab(_input) {
-  }
-  /** The second hand let go, leaving the object in the first hand alone. */
-  onSecondaryRelease(_input) {
+    }
+    return false;
   }
   /**
-   * A hand pose declared on this entity started being held.
-   *
-   * Fires once the pose has been sustained for its hold time, not the instant
-   * the fingers pass through it.
+   * Resize the composer only when the canvas size or pixel ratio changed, or
+   * when the composer itself was rebuilt. `setSize` resizes every render
+   * target in the chain, so calling it every frame wasted GPU work.
    */
-  onHandPoseStart(_event) {
-  }
-  /** A held hand pose ended, or its hand stopped being tracked. */
-  onHandPoseEnd(_event) {
-  }
-  onGrab(input) {
-  }
-  /** Called when this entity is released. Optional XR hook. */
-  onRelease(input) {
-  }
-  /** A UI button on this entity (or a descendant) was clicked. Clicks fire on
-   * RELEASE while still pointing at the widget — sliding off cancels. */
-  onUiPress(_event) {
-  }
-  /** A pointer began hovering a UI widget on this entity (or a descendant). */
-  onUiHoverStart(_event) {
-  }
-  /** The pointer left the widget. */
-  onUiHoverEnd(_event) {
-  }
-  /** A UI toggle flipped; `event.value` is the new boolean. */
-  onUiToggle(_event) {
-  }
-  /** A UI slider moved; `event.value` is the new number. Fires on real value
-   * changes during the drag and once more on release. */
-  onUiChange(_event) {
-  }
-};
-__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/scriptShared.ts
-async function defaultModuleLoader(scriptUrl) {
-  return await import(
-    /* webpackIgnore: true */
-    scriptUrl
-  );
-}
-__name(defaultModuleLoader, "defaultModuleLoader");
-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 resolveScriptCtor(moduleValue, className, options) {
-  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 options.baseClass)) {
-    const marker = candidate[options.markerKey];
-    if (!marker) {
-      return null;
+  syncComposerSize(composer) {
+    const width = Math.max(1, this.renderer.domElement.clientWidth);
+    const height = Math.max(1, this.renderer.domElement.clientHeight);
+    const pixelRatio = typeof this.renderer.getPixelRatio === "function" ? this.renderer.getPixelRatio() : 1;
+    const isNewComposer = composer !== this.sizedComposer;
+    if (!isNewComposer && width === this.sizedWidth && height === this.sizedHeight && pixelRatio === this.sizedPixelRatio) {
+      return;
     }
-  }
-  return candidate;
-}
-__name(resolveScriptCtor, "resolveScriptCtor");
-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;
+    if ((isNewComposer || pixelRatio !== this.sizedPixelRatio) && typeof composer.setPixelRatio === "function") {
+      composer.setPixelRatio(pixelRatio);
     }
-    const next = {};
-    for (const key of Object.keys(defaultValue)) {
-      next[key] = mergeValueByDefaultShape(defaultValue[key], currentValue[key]);
+    if (typeof composer.setSize === "function") {
+      composer.setSize(width, height);
     }
-    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;
+    this.sizedComposer = composer;
+    this.sizedWidth = width;
+    this.sizedHeight = height;
+    this.sizedPixelRatio = pixelRatio;
   }
-  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 };
-      }
+  update(_world) {
+    if (!this.isRendererReady()) {
+      return;
     }
-  }
-  return resolved;
-}
-__name(resolveInputData, "resolveInputData");
-function serializeDataForStorage(rawData, instanceData) {
-  const result = { ...instanceData };
-  for (const [key, rawValue] of Object.entries(rawData)) {
-    if (isRawEntityInput(rawValue) || isRawComponentInput(rawValue)) {
-      result[key] = rawValue;
+    if (this.scene.userData.ecsPostprocessingComposerActive === true) {
+      const composer = this.scene.userData.ecsPostprocessingComposer;
+      if (composer) {
+        this.syncComposerSize(composer);
+        composer.render();
+      } else {
+        this.renderer.render(this.scene, this.camera);
+      }
+      this.afterRender?.();
+      return;
     }
+    this.sizedComposer = null;
+    this.renderer.render(this.scene, this.camera);
+    this.afterRender?.();
   }
-  return result;
-}
-__name(serializeDataForStorage, "serializeDataForStorage");
-
-// core/systems/ScriptBehaviourSystem.ts
+};
+__name(_RenderSystem, "RenderSystem");
+var RenderSystem = _RenderSystem;
+var DEFAULT_SCRIPT_ERROR_RETRY_DELAY = 1;
 function buildInstanceKey(entityId, scriptUrl, className) {
   return `${entityId}:${scriptUrl}:${className}`;
 }
@@ -5385,9 +3187,13 @@ function writeScriptEntries(component, entries) {
 }
 __name(writeScriptEntries, "writeScriptEntries");
 var _ScriptBehaviourSystem = class _ScriptBehaviourSystem {
-  constructor(moduleLoader, selectionContext) {
+  constructor(moduleLoader, selectionContext, options) {
     this.instances = /* @__PURE__ */ new Map();
     this.loading = /* @__PURE__ */ new Map();
+    /** Seconds of world time this system has seen (sum of `deltaTime`). */
+    this.clock = 0;
+    /** Instance key → clock time before which a failed script is not retried. */
+    this.retryAt = /* @__PURE__ */ new Map();
     this.selectedEntityId = null;
     // undefined = nothing queued; null = queued "deselect all"; number = queued entity
     this.pendingEntityId = void 0;
@@ -5404,6 +3210,8 @@ var _ScriptBehaviourSystem = class _ScriptBehaviourSystem {
       this.queueRaycast(event.clientX, event.clientY);
     }, "onPointerUp");
     this.moduleLoader = moduleLoader ?? defaultModuleLoader;
+    const retryDelay = options?.errorRetryDelay;
+    this.errorRetryDelay = typeof retryDelay === "number" && Number.isFinite(retryDelay) ? Math.max(0, retryDelay) : DEFAULT_SCRIPT_ERROR_RETRY_DELAY;
     this.selectionCtx = selectionContext ?? null;
     this.raycaster = new THREE19.Raycaster();
     this.ndcPointer = new THREE19.Vector2();
@@ -5451,7 +3259,7 @@ var _ScriptBehaviourSystem = class _ScriptBehaviourSystem {
    * Calls onDeselect() on all behaviours of the previous entity and
    * onSelect() on all behaviours of the newly selected entity.
    */
-  applySelection(nextEntityId) {
+  applySelection(world, nextEntityId) {
     if (nextEntityId === this.selectedEntityId) return;
     const prevEntityId = this.selectedEntityId;
     this.selectedEntityId = nextEntityId;
@@ -5460,7 +3268,8 @@ var _ScriptBehaviourSystem = class _ScriptBehaviourSystem {
         if (record.entityId === prevEntityId) {
           try {
             record.behaviour.onDeselect();
-          } catch {
+          } catch (error) {
+            this.reportRecordError(world, record, "onDeselect", error);
           }
         }
       }
@@ -5470,18 +3279,39 @@ var _ScriptBehaviourSystem = class _ScriptBehaviourSystem {
         if (record.entityId === nextEntityId) {
           try {
             record.behaviour.onSelect();
-          } catch {
+          } catch (error) {
+            this.reportRecordError(world, record, "onSelect", error);
           }
         }
       }
     }
   }
+  reportRecordError(world, record, phase, error) {
+    reportScriptError(
+      world,
+      {
+        entityId: record.entityId,
+        scriptUrl: record.scriptUrl,
+        className: record.className,
+        phase,
+        source: "behaviour"
+      },
+      error
+    );
+  }
+  /** Hold a failed script back for {@link errorRetryDelay} seconds. */
+  scheduleRetry(key) {
+    this.retryAt.set(key, this.clock + this.errorRetryDelay);
+  }
   // ── ECS lifecycle ──────────────────────────────────────────────────────────
   update(world, deltaTime) {
+    if (Number.isFinite(deltaTime) && deltaTime > 0) {
+      this.clock += deltaTime;
+    }
     if (this.pendingEntityId !== void 0) {
       const next = this.pendingEntityId;
       this.pendingEntityId = void 0;
-      this.applySelection(next);
+      this.applySelection(world, next);
     }
     const active = /* @__PURE__ */ new Map();
     const entityIds = world.query(ScriptComponent);
@@ -5571,8 +3401,15 @@ var _ScriptBehaviourSystem = class _ScriptBehaviourSystem {
         if (script.entryIndex === 0) {
           script.scriptComponent.scriptInstance = null;
         }
-        record.behaviour.dispose?.(world);
+        script.scriptComponent.scriptInstances.delete(script.entryIndex);
+        this.reportRecordError(world, record, "update", error);
+        try {
+          record.behaviour.dispose?.(world);
+        } catch (disposeError) {
+          this.reportRecordError(world, record, "dispose", disposeError);
+        }
         this.instances.delete(key);
+        this.scheduleRetry(key);
       }
     }
     if (this.selectedEntityId !== null) {
@@ -5587,10 +3424,22 @@ var _ScriptBehaviourSystem = class _ScriptBehaviourSystem {
         this.selectedEntityId = null;
       }
     }
+    for (const key of this.retryAt.keys()) {
+      if (!active.has(key)) {
+        this.retryAt.delete(key);
+      }
+    }
     for (const [key, script] of active.entries()) {
       if (this.instances.has(key) || this.loading.has(key)) {
         continue;
       }
+      const retryAt = this.retryAt.get(key);
+      if (retryAt !== void 0) {
+        if (this.clock < retryAt) {
+          continue;
+        }
+        this.retryAt.delete(key);
+      }
       const entries = readScriptEntries(script.scriptComponent, script.entityId);
       const targetEntry = entries[script.entryIndex];
       if (targetEntry) {
@@ -5601,24 +3450,34 @@ var _ScriptBehaviourSystem = class _ScriptBehaviourSystem {
         };
         writeScriptEntries(script.scriptComponent, entries);
       }
-      const promise = this.loadBehaviour(world, script).catch((error) => {
+      const promise = this.loadBehaviour(world, script).catch((thrown) => {
+        const { phase, error } = readScriptPhase(thrown, "load");
+        const message = toErrorMessage(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."
+            runtimeMessage: phase === "load" ? `Failed to load script: ${message}` : message
           };
           writeScriptEntries(script.scriptComponent, liveEntries);
         }
         if (script.entryIndex === 0) {
           script.scriptComponent.scriptInstance = null;
         }
-        console.error(
-          `[ScriptBehaviourSystem] Failed loading script ${script.scriptEntry.className}`,
+        reportScriptError(
+          world,
+          {
+            entityId: script.entityId,
+            scriptUrl: script.scriptEntry.scriptUrl,
+            className: script.scriptEntry.className,
+            phase,
+            source: "behaviour"
+          },
           error
         );
+        this.scheduleRetry(key);
       }).finally(() => {
         this.loading.delete(key);
       });
@@ -5648,6 +3507,7 @@ var _ScriptBehaviourSystem = class _ScriptBehaviourSystem {
     }
     this.instances.clear();
     this.loading.clear();
+    this.retryAt.clear();
   }
   async loadBehaviour(world, script) {
     const { entityId, scriptComponent, entryIndex, scriptEntry } = script;
@@ -5656,11 +3516,19 @@ var _ScriptBehaviourSystem = class _ScriptBehaviourSystem {
       scriptEntry.scriptUrl,
       scriptEntry.className
     );
-    const moduleValue = await this.moduleLoader(scriptEntry.scriptUrl);
+    let moduleValue;
+    try {
+      moduleValue = await this.moduleLoader(scriptEntry.scriptUrl);
+    } catch (error) {
+      throw withScriptPhase("load", error);
+    }
     const ctor = resolveBehaviourCtor(moduleValue, scriptEntry.className);
     if (!ctor) {
-      throw new Error(
-        `Missing Behaviour export '${scriptEntry.className}' in ${scriptEntry.scriptUrl}`
+      throw withScriptPhase(
+        "load",
+        new Error(
+          `Missing Behaviour export '${scriptEntry.className}' in ${scriptEntry.scriptUrl}`
+        )
       );
     }
     if (!world.hasEntity(entityId)) {
@@ -5677,21 +3545,26 @@ var _ScriptBehaviourSystem = class _ScriptBehaviourSystem {
     }
     const currentData = normalizeScriptData(liveEntry.data);
     let behaviour;
+    let mergedData;
     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()) {
-      behaviour.init();
+      try {
+        behaviour = new ctor(
+          world,
+          entityId,
+          void 0
+        );
+      } catch {
+        behaviour = new ctor(world, entityId, currentData);
+      }
+      const defaults = normalizeScriptData(behaviour.data);
+      mergedData = mergeDataByCurrentDefaults(defaults, currentData);
+      const resolvedData = resolveInputData(world, mergedData);
+      behaviour.data = resolvedData;
+      if (!world.isEditorMode()) {
+        behaviour.init();
+      }
+    } catch (error) {
+      throw withScriptPhase("init", error);
     }
     liveEntries[entryIndex] = {
       ...liveEntry,
@@ -5798,9 +3671,12 @@ var _ScriptObjectSystem = class _ScriptObjectSystem {
     this.loading = /* @__PURE__ */ new Map();
     /** Bumped by invalidate*() so in-flight loads that predate it are discarded. */
     this.epoch = 0;
+    /** World seen by the last update(), so invalidate*() can reset error dedupe. */
+    this.lastWorld = null;
     this.moduleLoader = moduleLoader ?? defaultModuleLoader;
   }
   update(world, deltaTime) {
+    this.lastWorld = world;
     const active = /* @__PURE__ */ new Map();
     for (const entityId of world.query(ScriptObjectComponent)) {
       const component = world.getComponent(entityId, ScriptObjectComponent);
@@ -5841,14 +3717,14 @@ var _ScriptObjectSystem = class _ScriptObjectSystem {
           component.data = stored;
           record.lastWrittenData = stored;
         } catch (error) {
-          this.markError(world, entityId, component, error);
+          this.markError(world, entityId, component, error, "update");
           continue;
         }
       }
       try {
         record.instance.update?.(deltaTime);
       } catch (error) {
-        this.markError(world, entityId, component, error);
+        this.markError(world, entityId, component, error, "update");
       }
     }
     for (const [entityId, component] of active) {
@@ -5868,12 +3744,12 @@ var _ScriptObjectSystem = class _ScriptObjectSystem {
         className,
         key,
         epochAtStart
-      ).catch((error) => {
-        this.markError(world, entityId, void 0, error);
-        console.error(
-          `[ScriptObjectSystem] Failed loading ${className} (${scriptUrl})`,
-          error
-        );
+      ).catch((thrown) => {
+        const { phase, error } = readScriptPhase(thrown, "load");
+        this.markError(world, entityId, void 0, error, phase, {
+          scriptUrl,
+          className
+        });
       }).finally(() => {
         if (this.loading.get(entityId)?.key === key) {
           this.loading.delete(entityId);
@@ -5886,7 +3762,12 @@ var _ScriptObjectSystem = class _ScriptObjectSystem {
     }
   }
   async loadScriptObject(world, entityId, scriptUrl, className, key, epochAtStart) {
-    const moduleValue = await this.moduleLoader(scriptUrl);
+    let moduleValue;
+    try {
+      moduleValue = await this.moduleLoader(scriptUrl);
+    } catch (error) {
+      throw withScriptPhase("load", error);
+    }
     if (this.loading.get(entityId)?.key !== key || epochAtStart !== this.epoch || !world.hasEntity(entityId)) {
       return;
     }
@@ -5899,16 +3780,21 @@ var _ScriptObjectSystem = class _ScriptObjectSystem {
       markerKey: "__reluScriptObjectClass"
     });
     if (!ctor) {
-      throw new Error(
-        `Missing ScriptObject export '${className}' in ${scriptUrl}`
+      throw withScriptPhase(
+        "load",
+        new Error(`Missing ScriptObject export '${className}' in ${scriptUrl}`)
       );
     }
     const currentData = normalizeScriptData(component.data);
     let instance;
     try {
-      instance = new ctor(world, entityId, void 0);
-    } catch {
-      instance = new ctor(world, entityId, currentData);
+      try {
+        instance = new ctor(world, entityId, void 0);
+      } catch {
+        instance = new ctor(world, entityId, currentData);
+      }
+    } catch (error) {
+      throw withScriptPhase("init", error);
     }
     const literalDefaults = normalizeScriptData(instance.data);
     const seed = Object.keys(literalDefaults).length > 0 ? mergeDataByCurrentDefaults(literalDefaults, currentData) : { ...currentData };
@@ -5930,14 +3816,17 @@ var _ScriptObjectSystem = class _ScriptObjectSystem {
         instance.dispose?.();
       } catch {
       }
-      throw error;
+      throw withScriptPhase("build", error);
     }
     if (!built || built.isObject3D !== true) {
       try {
         instance.dispose?.();
       } catch {
       }
-      throw new Error("build() must return a THREE.Object3D.");
+      throw withScriptPhase(
+        "build",
+        new Error("build() must return a THREE.Object3D.")
+      );
     }
     built.userData[SCRIPT_OBJECT_ROOT_FLAG] = true;
     parent.add(built);
@@ -5985,12 +3874,24 @@ var _ScriptObjectSystem = class _ScriptObjectSystem {
       this.instances.delete(entityId);
     }
   }
-  markError(world, entityId, component, error) {
+  markError(world, entityId, component, error, phase, identity) {
     const comp = component ?? world.getComponent(entityId, ScriptObjectComponent) ?? null;
     if (comp) {
       comp.runtimeState = "error";
       comp.runtimeMessage = toErrorMessage(error);
     }
+    const existing = this.instances.get(entityId);
+    reportScriptError(
+      world,
+      {
+        entityId,
+        scriptUrl: identity?.scriptUrl ?? existing?.scriptUrl ?? comp?.scriptUrl ?? "",
+        className: identity?.className ?? existing?.className ?? comp?.className ?? "",
+        phase,
+        source: "scriptObject"
+      },
+      error
+    );
     const record = this.instances.get(entityId);
     if (record) {
       this.teardownRecord(world, entityId, record, true);
@@ -6010,6 +3911,7 @@ var _ScriptObjectSystem = class _ScriptObjectSystem {
   /** Dispose all live instances so the next update() reloads with fresh modules. */
   invalidateAll() {
     this.epoch += 1;
+    this.lastWorld?.clearScriptErrors?.();
     for (const [entityId, record] of [...this.instances]) {
       try {
         record.instance?.dispose?.();
@@ -6023,6 +3925,7 @@ var _ScriptObjectSystem = class _ScriptObjectSystem {
   /** Invalidate only the entities whose script matches `scriptUrl`. */
   invalidate(scriptUrl) {
     this.epoch += 1;
+    this.lastWorld?.clearScriptErrors?.(scriptUrl);
     for (const [entityId, record] of [...this.instances]) {
       if (record.scriptUrl !== scriptUrl) continue;
       try {
@@ -6068,6 +3971,112 @@ var _TransformSyncSystem = class _TransformSyncSystem {
 };
 __name(_TransformSyncSystem, "TransformSyncSystem");
 var TransformSyncSystem = _TransformSyncSystem;
+
+// core/audio/AudioMixer.ts
+var BUSES = ["sfx", "voice", "music"];
+var DUCK_GAIN = 0.45;
+var DUCK_ATTACK = 0.05;
+var DUCK_RELEASE = 0.3;
+var _AudioMixer = class _AudioMixer {
+  constructor(listener) {
+    this.listener = listener;
+    this.volumes = {
+      sfx: 1,
+      voice: 1,
+      music: 1
+    };
+    this.routed = /* @__PURE__ */ new WeakMap();
+    const input = listener.getInput();
+    const make = /* @__PURE__ */ __name(() => {
+      const gain = listener.context.createGain();
+      gain.connect(input);
+      return gain;
+    }, "make");
+    this.buses = { sfx: make(), voice: make(), music: make() };
+  }
+  /** The node a sound connects to for this bus. */
+  input(bus) {
+    return this.buses[bus] ?? this.buses.sfx;
+  }
+  /** Send a three.js sound through a bus. Does nothing when it's already there. */
+  route(sound, bus) {
+    if (this.routed.get(sound) === bus) return;
+    const output = sound.getOutput();
+    output.disconnect();
+    output.connect(this.input(bus));
+    this.routed.set(sound, bus);
+  }
+  setVolume(bus, volume) {
+    const v = Math.max(0, volume);
+    this.volumes[bus] = v;
+    this.input(bus).gain.setTargetAtTime(v, this.listener.context.currentTime, 0.02);
+  }
+  getVolume(bus) {
+    return this.volumes[bus];
+  }
+  /** Dip the music for `seconds`, then bring it back. A later duck replaces this one. */
+  duckMusic(seconds) {
+    const gain = this.buses.music.gain;
+    const now = this.listener.context.currentTime;
+    const full = this.volumes.music;
+    gain.cancelScheduledValues(now);
+    gain.setTargetAtTime(full * DUCK_GAIN, now, DUCK_ATTACK);
+    gain.setTargetAtTime(full, now + seconds, DUCK_RELEASE);
+  }
+  dispose() {
+    for (const bus of BUSES) this.buses[bus].disconnect();
+  }
+};
+__name(_AudioMixer, "AudioMixer");
+var AudioMixer = _AudioMixer;
+
+// core/audio/soundBank.ts
+function soundBankFiles(bank) {
+  const files = /* @__PURE__ */ new Set();
+  for (const slot of Object.values(bank.slots)) {
+    for (const take of slot.takes) if (take.file) files.add(take.file);
+  }
+  return [...files];
+}
+__name(soundBankFiles, "soundBankFiles");
+function assertSoundBank(value) {
+  const slots = value?.slots;
+  if (!slots || typeof slots !== "object") {
+    throw new Error("Not a sound bank: it has no slots.");
+  }
+  for (const [id, slot] of Object.entries(slots)) {
+    if (!Array.isArray(slot?.takes)) {
+      throw new Error(`Sound bank slot "${id}" has no takes list.`);
+    }
+  }
+}
+__name(assertSoundBank, "assertSoundBank");
+var _SlotChooser = class _SlotChooser {
+  constructor(random = Math.random) {
+    this.random = random;
+    this.lastPlay = /* @__PURE__ */ new Map();
+    this.lastTake = /* @__PURE__ */ new Map();
+  }
+  /** The take to play now, or `null` to stay silent. `now` is in milliseconds. */
+  choose(id, slot, now) {
+    const takes = slot.takes.filter((t) => t.file);
+    if (takes.length === 0) return null;
+    const last = this.lastPlay.get(id);
+    if (last !== void 0 && now - last < (slot.cooldownMs ?? 0)) return null;
+    if (this.random() >= (slot.chance ?? 1)) return null;
+    const previous = this.lastTake.get(id);
+    const fresh = takes.filter((t) => t.file !== previous);
+    const pool = fresh.length > 0 ? fresh : takes;
+    const take = pool[Math.min(pool.length - 1, Math.floor(this.random() * pool.length))];
+    this.lastPlay.set(id, now);
+    this.lastTake.set(id, take.file);
+    return take;
+  }
+};
+__name(_SlotChooser, "SlotChooser");
+var SlotChooser = _SlotChooser;
+
+// core/systems/AudioSystem.ts
 function snapshotOptions(opts) {
   return {
     loop: opts.loop,
@@ -6087,10 +4096,106 @@ var _AudioSystem = class _AudioSystem {
     this.prevOptions = /* @__PURE__ */ new Map();
     /** Tracks entities that were stopped due to invisibility. */
     this.stoppedDueToInvisibility = /* @__PURE__ */ new Set();
+    this.world = null;
+    this.mixer = null;
+    this.slots = /* @__PURE__ */ new Map();
+    this.buffers = /* @__PURE__ */ new Map();
+    this.chooser = new SlotChooser();
+    this.voice = null;
     this.isEditor = isEditor;
   }
+  /** Scripts can load a bank in `init`, before this system's first update. */
+  attachWorld(world) {
+    this.world = world;
+  }
+  /** The mixer, made with the listener on first use. */
+  getMixer() {
+    if (this.mixer) return this.mixer;
+    const listener = this.world?.getObjectManagementSystem()?.getOrCreateAudioListener();
+    if (!listener) return null;
+    this.mixer = new AudioMixer(listener);
+    return this.mixer;
+  }
+  /** Set a bus's volume (`0` silent, `1` as mixed). */
+  setBusVolume(bus, volume) {
+    this.getMixer()?.setVolume(bus, volume);
+  }
+  getBusVolume(bus) {
+    return this.getMixer()?.getVolume(bus) ?? 1;
+  }
+  /**
+   * Fetch a `.soundbank.json` and decode its recordings. Its slots add to any
+   * loaded before, and a slot id used twice takes the later one.
+   * @param source an asset path, or a script's `AssetInput` field
+   */
+  async loadSoundBank(source) {
+    if (this.isEditor) return;
+    const url = typeof source === "string" ? source : source.path;
+    const res = await fetch(resolvePrefabAssetUrl(url));
+    if (!res.ok) throw new Error(`Couldn't load the sound bank ${url}.`);
+    const bank = await res.json();
+    assertSoundBank(bank);
+    const context = this.getMixer()?.listener.context;
+    if (!context) throw new Error("Audio isn't ready yet.");
+    await Promise.all(
+      soundBankFiles(bank).map(async (file) => {
+        if (this.buffers.has(file)) return;
+        const audio = await fetch(resolvePrefabAssetUrl(file));
+        if (!audio.ok) throw new Error(`Couldn't load the sound ${file}.`);
+        this.buffers.set(file, await context.decodeAudioData(await audio.arrayBuffer()));
+      })
+    );
+    for (const [id, slot] of Object.entries(bank.slots)) this.slots.set(id, slot);
+  }
+  /**
+   * Play a named sound from a loaded bank. Returns whether it sounded: a slot's
+   * chance, cooldown and priority can each keep it quiet, and that's normal.
+   */
+  playSlot(id, options = {}) {
+    const slot = this.slots.get(id);
+    const mixer = this.getMixer();
+    if (!slot || !mixer) return false;
+    const context = mixer.listener.context;
+    const bus = slot.bus ?? "sfx";
+    const now = context.currentTime;
+    const priority = slot.priority ?? 0;
+    const speaking = this.voice && now < this.voice.until ? this.voice : null;
+    if (bus === "voice" && speaking && priority < speaking.priority) return false;
+    const take = this.chooser.choose(id, slot, now * 1e3);
+    const buffer = take ? this.buffers.get(take.file) : void 0;
+    if (!take || !buffer) return false;
+    if (context.state === "suspended") void context.resume();
+    const source = context.createBufferSource();
+    source.buffer = buffer;
+    const gain = context.createGain();
+    gain.gain.value = (slot.volume ?? 1) * (take.volume ?? 1) * (options.volume ?? 1);
+    source.connect(gain);
+    let tail = gain;
+    if (options.position) {
+      const panner = context.createPanner();
+      panner.positionX.value = options.position.x;
+      panner.positionY.value = options.position.y;
+      panner.positionZ.value = options.position.z;
+      gain.connect(panner);
+      tail = panner;
+    }
+    tail.connect(mixer.input(bus));
+    source.onended = () => {
+      source.disconnect();
+      gain.disconnect();
+      tail.disconnect();
+    };
+    if (bus === "voice") {
+      speaking?.source.stop();
+      this.voice = { priority, until: now + buffer.duration, source };
+      mixer.duckMusic(buffer.duration);
+    }
+    source.start();
+    return true;
+  }
   update(world, _deltaTime) {
     if (this.isEditor) return;
+    this.world = world;
     const entities = world.query(AudioComponent);
     const liveEntityIds = new Set(entities);
     for (const entityId of entities) {
@@ -6111,6 +4216,8 @@ var _AudioSystem = class _AudioSystem {
         }
       }
       this._syncOptions(entityId, component, sound);
+      const bus = component.options.bus ?? "sfx";
+      this.getMixer()?.route(sound, bus);
       const prevWasPlaying = this.prevPlayingState.get(entityId) ?? false;
       if (prevWasPlaying && !sound.isPlaying && component.isPlaying && !component.isPaused && !this.stoppedDueToInvisibility.has(entityId)) {
         component.isPlaying = false;
@@ -6118,6 +4225,9 @@ var _AudioSystem = class _AudioSystem {
       if (component.isPlaying && !sound.isPlaying) {
         if (sound.buffer) {
           sound.play();
+          if (bus === "voice") {
+            this.getMixer()?.duckMusic(sound.buffer.duration / (component.options.pitch || 1));
+          }
         }
       } else if (!component.isPlaying && sound.isPlaying) {
         if (component.isPaused) {
@@ -6166,6 +4276,12 @@ var _AudioSystem = class _AudioSystem {
     this.prevPlayingState.clear();
     this.prevOptions.clear();
     this.stoppedDueToInvisibility.clear();
+    this.voice?.source.stop();
+    this.voice = null;
+    this.slots.clear();
+    this.buffers.clear();
+    this.mixer?.dispose();
+    this.mixer = null;
   }
 };
 __name(_AudioSystem, "AudioSystem");
@@ -6219,7 +4335,7 @@ var _VideoSystem = class _VideoSystem {
           });
         }
       }
-      this._syncOptions(entityId, component, video);
+      this._syncOptions(world, entityId, component, video);
       const prev = this.prevIntent.get(entityId) ?? { isPlaying: false, isPaused: false };
       if (prev.isPlaying && video.paused && !video.seeking && component.isPlaying && !component.isPaused && !this.pausedDueToInvisibility.has(entityId)) {
         component.isPlaying = false;
@@ -6258,7 +4374,7 @@ var _VideoSystem = class _VideoSystem {
     }
   }
   /** Apply any changed options from the component to the video element and mesh. */
-  _syncOptions(entityId, component, video) {
+  _syncOptions(world, entityId, component, video) {
     const opts = component.options;
     const prev = this.prevOptions.get(entityId);
     if (!prev || prev.loop !== opts.loop) {
@@ -6275,19 +4391,13 @@ var _VideoSystem = class _VideoSystem {
       component.object.scale.set(opts.width, opts.height, 1);
     }
     const material = component.material;
-    if (material instanceof THREE19.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 (material && (!prev || prev.backgroundColor !== opts.backgroundColor || prev.similarity !== opts.similarity || prev.smoothness !== opts.smoothness || prev.spill !== opts.spill)) {
+      readWorldRenderBackend(world).updateChromaKeyMaterial(material, {
+        keyColor: opts.backgroundColor,
+        similarity: opts.similarity,
+        smoothness: opts.smoothness,
+        spill: opts.spill
+      });
     }
     if (opts.positional && component.audioNode instanceof THREE19.PositionalAudio) {
       const posAudio = component.audioNode;
@@ -6821,7 +4931,7 @@ var _XRInteractionSystem = class _XRInteractionSystem {
       record.twoHand = null;
       this.reanchor(world, input, record, interactable);
       this.grabs.set(input, record);
-      this.dispatch(world, entityId, (b) => b.onGrab(input));
+      this.dispatch(world, entityId, "onGrab", (b) => b.onGrab(input));
       return;
     }
     if (holders.length >= 2) return;
@@ -6884,7 +4994,12 @@ var _XRInteractionSystem = class _XRInteractionSystem {
       primaryHandOffset: this.handQuaternion(primary.input).invert().multiply(quatFromEulerVec(transform.rotation)),
       initialQuaternion: quatFromEulerVec(transform.rotation)
     };
-    this.dispatch(world, entityId, (b) => b.onSecondaryGrab(secondary.input));
+    this.dispatch(
+      world,
+      entityId,
+      "onSecondaryGrab",
+      (b) => b.onSecondaryGrab(secondary.input)
+    );
   }
   /** World point → the object's UNSCALED local space. */
   objectLocalPoint(transform, worldPoint) {
@@ -7124,7 +5239,7 @@ var _XRInteractionSystem = class _XRInteractionSystem {
       angularVelocity: new THREE19.Vector3()
     });
     if (role === "primary") {
-      this.dispatch(world, entityId, (b) => b.onGrab(input));
+      this.dispatch(world, entityId, "onGrab", (b) => b.onGrab(input));
     }
   }
   /** Drive every held object, once each, after grabs and releases settle. */
@@ -7252,6 +5367,7 @@ var _XRInteractionSystem = class _XRInteractionSystem {
         this.dispatch(
           world,
           held.entityId,
+          "onSecondaryRelease",
           (b) => b.onSecondaryRelease(input)
         );
       } else {
@@ -7260,7 +5376,7 @@ var _XRInteractionSystem = class _XRInteractionSystem {
         next.record.twoHand = null;
         next.record.restoreBodyType = held.restoreBodyType;
         this.reanchor(world, next.input, next.record, interactable);
-        this.dispatch(world, held.entityId, (b) => b.onRelease(input));
+        this.dispatch(world, held.entityId, "onRelease", (b) => b.onRelease(input));
       }
       held.tracker.clear();
       return;
@@ -7279,7 +5395,7 @@ var _XRInteractionSystem = class _XRInteractionSystem {
       }
     }
     held.tracker.clear();
-    this.dispatch(world, held.entityId, (b) => b.onRelease(input));
+    this.dispatch(world, held.entityId, "onRelease", (b) => b.onRelease(input));
   }
   releaseAll(world) {
     for (const input of Array.from(this.grabs.keys())) {
@@ -7306,7 +5422,7 @@ var _XRInteractionSystem = class _XRInteractionSystem {
       input.rayDirection.clone().normalize()
     );
   }
-  dispatch(world, entityId, visit) {
+  dispatch(world, entityId, hook, visit) {
     const script = world.getComponent(entityId, ScriptComponent);
     const instances = script?.scriptInstances;
     if (!instances) return;
@@ -7315,7 +5431,7 @@ var _XRInteractionSystem = class _XRInteractionSystem {
       try {
         visit(instance);
       } catch (error) {
-        console.error("[XRInteractionSystem] Behaviour hook failed:", error);
+        reportBehaviourHookError(world, entityId, instance, hook, error);
       }
     }
   }
@@ -7854,7 +5970,7 @@ var _XRSessionSystem = class _XRSessionSystem {
       this.inputSystem.attachSession(session);
     }
     this.applyTrackingOrigin(world, session ?? null);
-    this.forEachBehaviour(world, (behaviour) => {
+    this.forEachBehaviour(world, "onXRSessionStart", (behaviour) => {
       behaviour.onXRSessionStart(this.capabilities);
     });
   }
@@ -7909,7 +6025,7 @@ var _XRSessionSystem = class _XRSessionSystem {
     this.session = null;
     this.capabilities = NO_XR_CAPABILITIES;
     this.inputSystem?.detachSession();
-    this.forEachBehaviour(world, (behaviour) => {
+    this.forEachBehaviour(world, "onXRSessionEnd", (behaviour) => {
       behaviour.onXRSessionEnd();
     });
   }
@@ -7924,14 +6040,18 @@ var _XRSessionSystem = class _XRSessionSystem {
     if (!inputs || inputs.length === 0) return;
     for (const input of inputs) {
       if (input.selectStart) {
-        this.forEachBehaviour(world, (b) => b.onSelectStart(input));
+        this.forEachBehaviour(
+          world,
+          "onSelectStart",
+          (b) => b.onSelectStart(input)
+        );
       }
       if (input.selectEnd) {
-        this.forEachBehaviour(world, (b) => b.onSelectEnd(input));
+        this.forEachBehaviour(world, "onSelectEnd", (b) => b.onSelectEnd(input));
       }
     }
   }
-  forEachBehaviour(world, visit) {
+  forEachBehaviour(world, hook, visit) {
     for (const entityId of world.query(ScriptComponent)) {
       const script = world.getComponent(entityId, ScriptComponent);
       const instances = script?.scriptInstances;
@@ -7941,7 +6061,7 @@ var _XRSessionSystem = class _XRSessionSystem {
         try {
           visit(instance);
         } catch (error) {
-          console.error("[XRSessionSystem] Behaviour hook failed:", error);
+          reportBehaviourHookError(world, entityId, instance, hook, error);
         }
       }
     }
@@ -8758,12 +6878,13 @@ var _UIInteractionSystem = class _UIInteractionSystem {
         this.dispatchBubbling(
           world,
           this.mouseHover,
+          "onUiHoverEnd",
           (b, e) => b.onUiHoverEnd(e)
         );
       }
       if (hovered !== null) {
         this.setTint(world, hovered, HOVER_TINT);
-        this.dispatchBubbling(world, hovered, (b, e) => b.onUiHoverStart(e));
+        this.dispatchBubbling(world, hovered, "onUiHoverStart", (b, e) => b.onUiHoverStart(e));
       }
       this.mouseHover = hovered;
     }
@@ -8829,7 +6950,7 @@ var _UIInteractionSystem = class _UIInteractionSystem {
   }
   fire(world, press, input) {
     if (press.kind === "button") {
-      this.dispatchBubbling(world, press.entityId, (b, e) => b.onUiPress(e), input);
+      this.dispatchBubbling(world, press.entityId, "onUiPress", (b, e) => b.onUiPress(e), input);
       return;
     }
     if (press.kind === "toggle") {
@@ -8839,6 +6960,7 @@ var _UIInteractionSystem = class _UIInteractionSystem {
       this.dispatchBubbling(
         world,
         press.entityId,
+        "onUiToggle",
         (b, e) => b.onUiToggle(e),
         input,
         toggle.value
@@ -8850,6 +6972,7 @@ var _UIInteractionSystem = class _UIInteractionSystem {
     this.dispatchBubbling(
       world,
       press.entityId,
+      "onUiChange",
       (b, e) => b.onUiChange(e),
       input,
       slider.value
@@ -8879,6 +7002,7 @@ var _UIInteractionSystem = class _UIInteractionSystem {
     this.dispatchBubbling(
       world,
       entityId,
+      "onUiChange",
       (b, e) => b.onUiChange(e),
       input,
       next
@@ -8911,7 +7035,7 @@ var _UIInteractionSystem = class _UIInteractionSystem {
    * panel script hears its children. Bubbling (not a world broadcast) keeps
    * two spawned copies of the same menu prefab independent.
    */
-  dispatchBubbling(world, entityId, visit, input = null, value) {
+  dispatchBubbling(world, entityId, hook, visit, input = null, value) {
     const event = {
       targetEntityId: entityId,
       actionId: this.actionIdOf(world, entityId),
@@ -8931,7 +7055,7 @@ var _UIInteractionSystem = class _UIInteractionSystem {
           try {
             visit(instance, event);
           } catch (error) {
-            console.error("[UIInteractionSystem] hook failed:", error);
+            reportBehaviourHookError(world, current, instance, hook, error);
           }
         }
       }
@@ -9507,7 +7631,8 @@ var _UIPanelSystem = class _UIPanelSystem {
     texture.magFilter = THREE19.LinearFilter;
     texture.premultiplyAlpha = true;
     try {
-      const max = world.getRenderer().capabilities?.getMaxAnisotropy?.();
+      const renderer = world.getRenderer();
+      const max = renderer.capabilities?.getMaxAnisotropy?.() ?? renderer.getMaxAnisotropy?.();
       if (typeof max === "number") texture.anisotropy = Math.min(8, max);
     } catch {
     }
@@ -9821,6 +7946,171 @@ var _XRAnchorSystem = class _XRAnchorSystem {
 };
 __name(_XRAnchorSystem, "XRAnchorSystem");
 var XRAnchorSystem = _XRAnchorSystem;
+var _q = new THREE19.Quaternion();
+var _q2 = new THREE19.Quaternion();
+var _s = new THREE19.Vector3();
+var _e = new THREE19.Vector3();
+var _w = new THREE19.Vector3();
+var _v = new THREE19.Vector3();
+var _p = new THREE19.Vector3();
+function setWorldQuaternion(o, q) {
+  if (o.parent) {
+    o.parent.getWorldQuaternion(_q2).invert();
+    o.quaternion.copy(_q2.multiply(q));
+  } else {
+    o.quaternion.copy(q);
+  }
+  o.updateMatrixWorld(true);
+}
+__name(setWorldQuaternion, "setWorldQuaternion");
+function turn(o, q) {
+  o.getWorldQuaternion(_q);
+  setWorldQuaternion(o, q.clone().multiply(_q));
+}
+__name(turn, "turn");
+function twoBoneIK(upper, lower, end, target, pole) {
+  upper.getWorldPosition(_s);
+  lower.getWorldPosition(_e);
+  end.getWorldPosition(_w);
+  const a = _s.distanceTo(_e);
+  const b = _e.distanceTo(_w);
+  if (a < 1e-6 || b < 1e-6) return target.distanceTo(_w);
+  const toT = _v.subVectors(target, _s);
+  const want = toT.length();
+  const c = THREE19.MathUtils.clamp(want, Math.abs(a - b) + 1e-4, a + b - 1e-4);
+  const dir = toT.divideScalar(want || 1).clone();
+  const pv = _p.subVectors(pole, _s);
+  pv.addScaledVector(dir, -pv.dot(dir));
+  if (pv.lengthSq() < 1e-8) pv.set(0, -1, 0).addScaledVector(dir, dir.y);
+  pv.normalize();
+  const cosA = THREE19.MathUtils.clamp((a * a + c * c - b * b) / (2 * a * c), -1, 1);
+  const joint = _s.clone().addScaledVector(dir, a * cosA).addScaledVector(pv, a * Math.sqrt(1 - cosA * cosA));
+  turn(upper, new THREE19.Quaternion().setFromUnitVectors(_e.clone().sub(_s).normalize(), joint.clone().sub(_s).normalize()));
+  lower.getWorldPosition(_e);
+  end.getWorldPosition(_w);
+  const reach = _s.clone().addScaledVector(dir, c);
+  turn(lower, new THREE19.Quaternion().setFromUnitVectors(_w.clone().sub(_e).normalize(), reach.clone().sub(_e).normalize()));
+  return want - c;
+}
+__name(twoBoneIK, "twoBoneIK");
+function gripQuaternion(axis, back, forearm, out = new THREE19.Quaternion()) {
+  let X = axis.clone();
+  const Z = back.clone().addScaledVector(X, -back.dot(X)).normalize().negate();
+  let Y = new THREE19.Vector3().crossVectors(Z, X);
+  if (Y.dot(forearm) < 0) {
+    X = X.negate();
+    Y = Y.negate();
+  }
+  return out.setFromRotationMatrix(new THREE19.Matrix4().makeBasis(X, Y, Z));
+}
+__name(gripQuaternion, "gripQuaternion");
+
+// core/systems/IKSystem.ts
+var LIMB_BONES = {
+  leftHand: ["leftUpperArm", "leftLowerArm", "leftHand"],
+  rightHand: ["rightUpperArm", "rightLowerArm", "rightHand"],
+  leftFoot: ["leftUpperLeg", "leftLowerLeg", "leftFoot"],
+  rightFoot: ["rightUpperLeg", "rightLowerLeg", "rightFoot"]
+};
+var _t = new THREE19.Vector3();
+var _p2 = new THREE19.Vector3();
+var _q3 = new THREE19.Quaternion();
+var _pq = new THREE19.Quaternion();
+var _IKSystem = class _IKSystem {
+  constructor() {
+    this.runtimes = /* @__PURE__ */ new Map();
+    this.reach = /* @__PURE__ */ new Map();
+  }
+  /** How far a limb's end stayed from its target last frame, in metres (0 = reached). */
+  getReachError(entityId, limb) {
+    return this.reach.get(`${entityId}:${limb}`) ?? null;
+  }
+  restore(runtime) {
+    for (const [bone, w] of runtime.written) {
+      if (bone.quaternion.equals(w.written)) bone.quaternion.copy(w.before);
+    }
+    runtime.written.clear();
+  }
+  update(world) {
+    const ids = world.query(IKComponent, ModelComponent);
+    const alive = new Set(ids);
+    for (const [id, runtime] of this.runtimes) {
+      if (!alive.has(id)) {
+        this.restore(runtime);
+        this.runtimes.delete(id);
+      }
+    }
+    if (ids.length === 0) return;
+    let matricesFresh = false;
+    for (const id of ids) {
+      const ik = world.getComponent(id, IKComponent);
+      const root = world.getComponent(id, ModelComponent)?.object;
+      if (!ik || !root) continue;
+      let runtime = this.runtimes.get(id);
+      if (!runtime || runtime.rootUuid !== root.uuid) {
+        if (runtime) this.restore(runtime);
+        runtime = { rootUuid: root.uuid, limbs: /* @__PURE__ */ new Map(), written: /* @__PURE__ */ new Map() };
+        this.runtimes.set(id, runtime);
+      }
+      for (const [bone, w] of runtime.written) {
+        if (bone.quaternion.equals(w.written)) bone.quaternion.copy(w.before);
+      }
+      runtime.written.clear();
+      if (!ik.enabled) continue;
+      const active = ik.chains.filter((c) => c.enabled && c.weight > 0 && typeof c.target === "number");
+      if (active.length === 0) continue;
+      if (!matricesFresh) {
+        world.getScene().updateMatrixWorld(true);
+        matricesFresh = true;
+      }
+      for (const chain of active) {
+        let limb = runtime.limbs.get(chain.limb);
+        if (!limb) {
+          const names = LIMB_BONES[chain.limb];
+          const found = names.map((h) => findModelBone(root, { humanoid: h }));
+          limb = { bones: found.every(Boolean) ? found : null };
+          runtime.limbs.set(chain.limb, limb);
+        }
+        const target = world.getComponent(chain.target, Object3DRef)?.object;
+        if (!limb.bones || !target) continue;
+        const [upper, lower, end] = limb.bones;
+        for (const bone of [upper, lower, end]) {
+          if (!runtime.written.has(bone)) {
+            runtime.written.set(bone, { before: bone.quaternion.clone(), written: new THREE19.Quaternion() });
+          }
+        }
+        const animated = [upper.quaternion.clone(), lower.quaternion.clone(), end.quaternion.clone()];
+        target.getWorldPosition(_t);
+        const poleObject = typeof chain.pole === "number" ? world.getComponent(chain.pole, Object3DRef)?.object : null;
+        if (poleObject) poleObject.getWorldPosition(_p2);
+        else lower.getWorldPosition(_p2);
+        const miss = twoBoneIK(upper, lower, end, _t, _p2);
+        this.reach.set(`${id}:${chain.limb}`, Math.max(0, miss));
+        if (chain.matchRotation) {
+          target.getWorldQuaternion(_q3);
+          end.parent?.getWorldQuaternion(_pq);
+          end.quaternion.copy(_pq.invert().multiply(_q3));
+        }
+        if (chain.weight < 1) {
+          [upper, lower, end].forEach((bone, i) => {
+            bone.quaternion.copy(animated[i].slerp(bone.quaternion, chain.weight));
+          });
+        }
+        for (const bone of [upper, lower, end]) {
+          bone.updateMatrixWorld(true);
+          const w = runtime.written.get(bone);
+          if (w) w.written.copy(bone.quaternion);
+        }
+      }
+    }
+  }
+  dispose() {
+    for (const runtime of this.runtimes.values()) this.restore(runtime);
+    this.runtimes.clear();
+  }
+};
+__name(_IKSystem, "IKSystem");
+var IKSystem = _IKSystem;
 function buildGeometry2(area) {
   if (area.shape === "circle") {
     const radius = Math.max(5e-3, area.width / 2);
@@ -10887,7 +9177,13 @@ var _XRHandPoseSystem = class _XRHandPoseSystem {
         if (event === "start") instance.onHandPoseStart(detail);
         else instance.onHandPoseEnd(detail);
       } catch (error) {
-        console.error("[XRHandPoseSystem] Behaviour hook failed:", error);
+        reportBehaviourHookError(
+          world,
+          entityId,
+          instance,
+          event === "start" ? "onHandPoseStart" : "onHandPoseEnd",
+          error
+        );
       }
     }
   }
@@ -10977,15 +9273,15 @@ var _XRHoverVisualSystem = class _XRHoverVisualSystem {
     object.traverse((child) => {
       if (!(child instanceof THREE19.Mesh) || !child.geometry) return;
       if (child.userData[XR_HOVER_SHELL_FLAG]) return;
-      const clone2 = new THREE19.Mesh(child.geometry, material);
+      const clone = new THREE19.Mesh(child.geometry, material);
       child.updateWorldMatrix(true, false);
       object.updateWorldMatrix(true, false);
-      clone2.matrixAutoUpdate = false;
-      clone2.matrix.copy(object.matrixWorld).invert().multiply(child.matrixWorld).scale(new THREE19.Vector3(SHELL_INFLATE, SHELL_INFLATE, SHELL_INFLATE));
-      clone2.userData[XR_HOVER_SHELL_FLAG] = true;
-      clone2.raycast = () => {
+      clone.matrixAutoUpdate = false;
+      clone.matrix.copy(object.matrixWorld).invert().multiply(child.matrixWorld).scale(new THREE19.Vector3(SHELL_INFLATE, SHELL_INFLATE, SHELL_INFLATE));
+      clone.userData[XR_HOVER_SHELL_FLAG] = true;
+      clone.raycast = () => {
       };
-      group.add(clone2);
+      group.add(clone);
     });
     if (group.children.length === 0) {
       material.dispose();
@@ -11055,6 +9351,6 @@ var _XRHoverVisualSystem = class _XRHoverVisualSystem {
 __name(_XRHoverVisualSystem, "XRHoverVisualSystem");
 var XRHoverVisualSystem = _XRHoverVisualSystem;
 
-export { ADDED_NODE_MARKER_COMPONENT, ARC_GRAVITY, ARC_MAX_TIME, ARC_SPEED, ARC_STEPS, AnimationSystem, AudioSystem, Behaviour, CURLED_COS, CameraSyncSystem, DEFAULT_DIRECTION_TOLERANCE, DEFAULT_ENTER_CONFIDENCE, DEFAULT_EXIT_CONFIDENCE, DEFAULT_LOST_GRACE_SECONDS, DEFAULT_MIN_HOLD_SECONDS, EnvironmentSyncSystem, FALLBACK_HAND_SCALE, HYDRATABLE_ENTITY_KINDS, HandPoseTracker, InputSystem, InstancedMeshSystem, KeyboardKeys, LightSyncSystem, MATCH_FALLOFF, MAX_PLAUSIBLE_SPEED, MAX_SAMPLE_AGE_SECONDS, MaterialSyncSystem, MeshGeometrySystem, NODE_KEY_SEPARATOR, NO_XR_CAPABILITIES, OVERRIDE_DIFF_EXCLUDED_COMPONENTS, OVERRIDE_ROOT_EXCLUDED_COMPONENTS, ObjectVisibilitySystem, PINCH_FINGERS, PREFAB_FILE_VERSION, PREFAB_FILE_VERSION_NESTED, PhysicsSyncSystem, PostprocessingSyncSystem, RenderSystem, SCRIPT_OBJECT_ROOT_FLAG, STRAIGHT_COS, ScriptBehaviourSystem, ScriptObject, ScriptObjectSystem, TeleportAimGate, ThrowVelocityTracker, TransformSyncSystem, UIInteractionSystem, UIPanelSystem, VELOCITY_SAMPLES, VRTeleportAreaSystem, VideoSystem, XRAnchorSystem, XRControllerVisualSystem, XREnvironmentSystem, XRHandPoseSystem, XRHitTestSystem, XRHoverVisualSystem, XRInputSystem, XRInteractionSystem, XRLocomotionSystem, XRSessionSystem, XRTeleportVisualSystem, XR_FINGERS, XR_HOVER_SHELL_FLAG, angularVelocityFrom, applyHandMaterial, arcGroundCrossing, buildComponentValueMaps, buildNodeKeyMapsFromSnapshot, buildNodeMapsFromSnapshot, canonicalizeComponentValue, clearPrefabCache, collectDiffPaths, collectEntitySubtree, collectSnapshotSubtreeIds, computeFingerCurl, computeHandShape, computeInstanceOverrides, computePalmPose, computePalmWidth, computePinch, computeSpread, createHandMaterial, decanonicalizeComponentValue, despawnPrefab, encodeOverride, estimateHandScale, findSnapshotRootEntityIds, findTopLevelNestedRegions, groupOverridePaths, hydrateWorldFromSnapshot, hydrateWorldFromSnapshotDetailed, indexSnapshotByEntity, instantiateSubtree, loadPrefab, matchHandPose, mergeComponentValue, parseOverride, parsePrefabAsset, prefabFileVersionFor, readXrCapabilities, restoreComponentState, restorePostCreateComponents, sampleTeleportArc, setPrefabAssetUrlResolver, spawnPrefab };
-//# sourceMappingURL=chunk-DF5SSRN6.js.map
-//# sourceMappingURL=chunk-DF5SSRN6.js.map
+export { ARC_GRAVITY, ARC_MAX_TIME, ARC_SPEED, ARC_STEPS, AnimationSystem, AudioMixer, AudioSystem, CURLED_COS, CameraSyncSystem, DEFAULT_DIRECTION_TOLERANCE, DEFAULT_ENTER_CONFIDENCE, DEFAULT_EXIT_CONFIDENCE, DEFAULT_LOST_GRACE_SECONDS, DEFAULT_MIN_HOLD_SECONDS, DEFAULT_SCRIPT_ERROR_RETRY_DELAY, EnvironmentSyncSystem, FALLBACK_HAND_SCALE, HandPoseTracker, IKSystem, InputSystem, InstancedMeshSystem, KeyboardKeys, LightSyncSystem, MATCH_FALLOFF, MAX_PLAUSIBLE_SPEED, MAX_SAMPLE_AGE_SECONDS, MaterialSyncSystem, MeshGeometrySystem, NO_XR_CAPABILITIES, ObjectVisibilitySystem, PINCH_FINGERS, PhysicsSyncSystem, PostprocessingSyncSystem, RenderSystem, SCRIPT_OBJECT_ROOT_FLAG, STRAIGHT_COS, ScriptBehaviourSystem, ScriptObject, ScriptObjectSystem, SlotChooser, TeleportAimGate, ThrowVelocityTracker, TransformSyncSystem, UIInteractionSystem, UIPanelSystem, VELOCITY_SAMPLES, VRTeleportAreaSystem, VideoSystem, XRAnchorSystem, XRControllerVisualSystem, XREnvironmentSystem, XRHandPoseSystem, XRHitTestSystem, XRHoverVisualSystem, XRInputSystem, XRInteractionSystem, XRLocomotionSystem, XRSessionSystem, XRTeleportVisualSystem, XR_FINGERS, XR_HOVER_SHELL_FLAG, angularVelocityFrom, applyHandMaterial, arcGroundCrossing, computeFingerCurl, computeHandShape, computePalmPose, computePalmWidth, computePinch, computeSpread, createHandMaterial, estimateHandScale, gripQuaternion, matchHandPose, readXrCapabilities, sampleTeleportArc, setWorldQuaternion, soundBankFiles, twoBoneIK };
+//# sourceMappingURL=chunk-JIJQFW6P.js.map
+//# sourceMappingURL=chunk-JIJQFW6P.js.map