@relu-interactives/spatial-ecs 0.3.9 → 0.3.11

package/dist/{chunk-W5TSYV6Q.js → chunk-KLU2M43M.js}

@@ -1,7 +1,7 @@
-import { resolveDracoDecoderPath, applyTransform, SHARED_MODEL_RESOURCE_FLAG } from './chunk-L5BP727H.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, XRHandPoseComponent, createHandPoseEntry, XRInteractorComponent, XRInteractorSideComponent, InstanceSlotComponent, Name, ImageComponent, SpriteComponent, VideoComponent, AudioComponent, ImageTarget, Selectable, PrefabNode, PrefabInstance, handPoseDefinitionFor, getHandPosePreset } from './chunk-KVGGAL5V.js';
+import { resolveDracoDecoderPath, applyTransform, SHARED_MODEL_RESOURCE_FLAG } from './chunk-Y3AC3VZ2.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, XRInteractorComponent, XRInteractorSideComponent, InstanceSlotComponent, Name, ImageComponent, SpriteComponent, VideoComponent, AudioComponent, ImageTarget, Selectable, PrefabNode, PrefabInstance, handPoseDefinitionFor, getHandPosePreset } from './chunk-TXEGYR76.js';
 import { __name } from './chunk-OY7ZODZP.js';
-import * as THREE7 from 'three';
+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';
@@ -160,7 +160,7 @@ function transitionToClip(runtime, nextClipId, crossFadeDuration) {
 }
 __name(transitionToClip, "transitionToClip");
 function applyActionState(action, component, paused, shouldLoop) {
-  const loopMode = shouldLoop ? THREE7.LoopRepeat : THREE7.LoopOnce;
+  const loopMode = shouldLoop ? THREE19.LoopRepeat : THREE19.LoopOnce;
   const repetitions = shouldLoop ? Infinity : 1;
   action.setLoop(loopMode, repetitions);
   action.clampWhenFinished = !shouldLoop;
@@ -333,7 +333,7 @@ var _AnimationSystem = class _AnimationSystem {
         if (runtime) {
           stopAllActions(runtime);
         }
-        const mixer = new THREE7.AnimationMixer(root);
+        const mixer = new THREE19.AnimationMixer(root);
         const entries2 = readRuntimeClipEntries(animation);
         const indexedActions = createActions(mixer, entries2);
         runtime = {
@@ -459,11 +459,11 @@ function normalizeOrthoBounds(component) {
 }
 __name(normalizeOrthoBounds, "normalizeOrthoBounds");
 function isPerspectiveCamera(camera) {
-  return camera instanceof THREE7.PerspectiveCamera;
+  return camera instanceof THREE19.PerspectiveCamera;
 }
 __name(isPerspectiveCamera, "isPerspectiveCamera");
 function isOrthographicCamera(camera) {
-  return camera instanceof THREE7.OrthographicCamera;
+  return camera instanceof THREE19.OrthographicCamera;
 }
 __name(isOrthographicCamera, "isOrthographicCamera");
 function readWindowAspect() {
@@ -517,7 +517,7 @@ var _CameraSyncSystem = class _CameraSyncSystem {
         continue;
       }
       const camera = objectRef.object;
-      if (!(camera instanceof THREE7.Camera)) {
+      if (!(camera instanceof THREE19.Camera)) {
         continue;
       }
       if (xrCamera !== null && camera === xrCamera) {
@@ -584,7 +584,7 @@ var MIN_DENSITY = 0;
 function createGradientTexture(effect, colors) {
   if (typeof document === "undefined") {
     const pixel = new Uint8Array([30, 30, 30, 255]);
-    const fallback = new THREE7.DataTexture(pixel, 1, 1, THREE7.RGBAFormat);
+    const fallback = new THREE19.DataTexture(pixel, 1, 1, THREE19.RGBAFormat);
     fallback.needsUpdate = true;
     return fallback;
   }
@@ -593,7 +593,7 @@ function createGradientTexture(effect, colors) {
   canvas.height = 512;
   const context = canvas.getContext("2d");
   if (!context) {
-    const fallback = new THREE7.CanvasTexture(canvas);
+    const fallback = new THREE19.CanvasTexture(canvas);
     fallback.needsUpdate = true;
     return fallback;
   }
@@ -621,15 +621,15 @@ function createGradientTexture(effect, colors) {
     context.fillRect(0, 0, 512, 512);
     context.globalCompositeOperation = "source-over";
   }
-  const texture = new THREE7.CanvasTexture(canvas);
-  texture.colorSpace = THREE7.SRGBColorSpace;
+  const texture = new THREE19.CanvasTexture(canvas);
+  texture.colorSpace = THREE19.SRGBColorSpace;
   texture.needsUpdate = true;
   return texture;
 }
 __name(createGradientTexture, "createGradientTexture");
 var _EnvironmentSyncSystem = class _EnvironmentSyncSystem {
   constructor(scene) {
-    this.textureLoader = new THREE7.TextureLoader();
+    this.textureLoader = new THREE19.TextureLoader();
     this.signature = null;
     this.activeTexture = null;
     this.pendingImageUrl = null;
@@ -652,7 +652,7 @@ var _EnvironmentSyncSystem = class _EnvironmentSyncSystem {
     if (skybox.type === "color") {
       this.disposeActiveTexture();
       this.pendingImageUrl = null;
-      this.scene.background = new THREE7.Color(skybox.color || "#1e1e1e");
+      this.scene.background = new THREE19.Color(skybox.color || "#1e1e1e");
       return;
     }
     if (skybox.type === "gradient") {
@@ -686,7 +686,7 @@ var _EnvironmentSyncSystem = class _EnvironmentSyncSystem {
           texture.dispose();
           return;
         }
-        texture.colorSpace = THREE7.SRGBColorSpace;
+        texture.colorSpace = THREE19.SRGBColorSpace;
         this.activeTexture = texture;
         this.scene.background = texture;
       },
@@ -705,16 +705,16 @@ var _EnvironmentSyncSystem = class _EnvironmentSyncSystem {
       this.scene.fog = null;
       return;
     }
-    const fogColor = new THREE7.Color(fog.color || "#1e1e1e");
+    const fogColor = new THREE19.Color(fog.color || "#1e1e1e");
     if (fog.type === "linear") {
       const near = Number.isFinite(fog.linear.near) ? fog.linear.near : 1;
       const farCandidate = Number.isFinite(fog.linear.far) ? fog.linear.far : near + 10;
       const far = Math.max(near + MIN_FOG_DELTA, farCandidate);
-      this.scene.fog = new THREE7.Fog(fogColor, near, far);
+      this.scene.fog = new THREE19.Fog(fogColor, near, far);
       return;
     }
     const density = Number.isFinite(fog.exponential.density) ? Math.max(MIN_DENSITY, fog.exponential.density) : 2e-3;
-    this.scene.fog = new THREE7.FogExp2(fogColor, density);
+    this.scene.fog = new THREE19.FogExp2(fogColor, density);
   }
   update(world) {
     const entityIds = world.query(Environment);
@@ -796,10 +796,10 @@ var _PostprocessingSyncSystem = class _PostprocessingSyncSystem {
       );
     }
     if (values.bloom.enabled) {
-      const size = this.renderer.getSize(new THREE7.Vector2());
+      const size = this.renderer.getSize(new THREE19.Vector2());
       composer.addPass(
         new UnrealBloomPass(
-          new THREE7.Vector2(size.width, size.height),
+          new THREE19.Vector2(size.width, size.height),
           values.bloom.intensity,
           values.bloom.radius,
           values.bloom.threshold
@@ -844,7 +844,7 @@ var _PostprocessingSyncSystem = class _PostprocessingSyncSystem {
     if (values.dotScreen.enabled) {
       composer.addPass(
         new DotScreenPass(
-          new THREE7.Vector2(0, 0),
+          new THREE19.Vector2(0, 0),
           values.dotScreen.angle ?? values.dotScreen.dotScreenAngle,
           values.dotScreen.scale ?? values.dotScreen.dotScreenScale
         )
@@ -901,6 +901,20 @@ var _PostprocessingSyncSystem = class _PostprocessingSyncSystem {
 __name(_PostprocessingSyncSystem, "PostprocessingSyncSystem");
 var PostprocessingSyncSystem = _PostprocessingSyncSystem;
 var MIN_SIZE = 1e-4;
+function toBodyType(RAPIER, bodyType) {
+  switch (bodyType) {
+    case "fixed":
+      return RAPIER.RigidBodyType.Fixed;
+    case "kinematicPosition":
+      return RAPIER.RigidBodyType.KinematicPositionBased;
+    case "kinematicVelocity":
+      return RAPIER.RigidBodyType.KinematicVelocityBased;
+    case "dynamic":
+    default:
+      return RAPIER.RigidBodyType.Dynamic;
+  }
+}
+__name(toBodyType, "toBodyType");
 function createRigidBodyDesc(RAPIER, bodyType) {
   if (bodyType === "fixed") {
     return RAPIER.RigidBodyDesc.fixed();
@@ -918,7 +932,7 @@ function computeColliderState(colliderValues, object) {
   if (!object) {
     return colliderValues;
   }
-  const scale = new THREE7.Vector3();
+  const scale = new THREE19.Vector3();
   object.getWorldScale(scale);
   return {
     ...colliderValues,
@@ -969,8 +983,8 @@ function createColliderDesc(RAPIER, values, triMeshData) {
     values.offsetPosition.y,
     values.offsetPosition.z
   );
-  const offsetQuaternion = new THREE7.Quaternion().setFromEuler(
-    new THREE7.Euler(
+  const offsetQuaternion = new THREE19.Quaternion().setFromEuler(
+    new THREE19.Euler(
       values.offsetRotation.x,
       values.offsetRotation.y,
       values.offsetRotation.z
@@ -985,17 +999,17 @@ function collectTriMeshParts(object) {
     return null;
   }
   object.updateWorldMatrix(true, true);
-  const worldScale = new THREE7.Vector3();
+  const worldScale = new THREE19.Vector3();
   object.getWorldScale(worldScale);
   const scale = {
     x: Math.abs(worldScale.x) || 1,
     y: Math.abs(worldScale.y) || 1,
     z: Math.abs(worldScale.z) || 1
   };
-  const worldToObject = new THREE7.Matrix4().copy(object.matrixWorld).invert();
+  const worldToObject = new THREE19.Matrix4().copy(object.matrixWorld).invert();
   const parts = [];
   object.traverse((child) => {
-    if (!(child instanceof THREE7.Mesh) || !child.geometry) {
+    if (!(child instanceof THREE19.Mesh) || !child.geometry) {
       return;
     }
     const geometry = child.geometry;
@@ -1012,7 +1026,7 @@ function collectTriMeshParts(object) {
     if (indexCount < 3) {
       return;
     }
-    const relativeMatrix = new THREE7.Matrix4().multiplyMatrices(
+    const relativeMatrix = new THREE19.Matrix4().multiplyMatrices(
       worldToObject,
       child.matrixWorld
     );
@@ -1053,7 +1067,7 @@ function createTriMeshData(collected) {
   }
   const vertices = new Float32Array(vertexTotal * 3);
   const indices = new Uint32Array(indexTotal);
-  const point = new THREE7.Vector3();
+  const point = new THREE19.Vector3();
   let vertexOffset = 0;
   let indexOffset = 0;
   for (const part of parts) {
@@ -1085,8 +1099,8 @@ function createTriMeshData(collected) {
 }
 __name(createTriMeshData, "createTriMeshData");
 function syncBodyFromTransform(body, transform) {
-  const quaternion = new THREE7.Quaternion().setFromEuler(
-    new THREE7.Euler(transform.rotation.x, transform.rotation.y, transform.rotation.z)
+  const quaternion = new THREE19.Quaternion().setFromEuler(
+    new THREE19.Euler(transform.rotation.x, transform.rotation.y, transform.rotation.z)
   );
   body.setTranslation(
     {
@@ -1113,8 +1127,8 @@ function syncTransformFromBody(transform, body) {
   transform.position.x = position.x;
   transform.position.y = position.y;
   transform.position.z = position.z;
-  const euler = new THREE7.Euler().setFromQuaternion(
-    new THREE7.Quaternion(rotation.x, rotation.y, rotation.z, rotation.w)
+  const euler = new THREE19.Euler().setFromQuaternion(
+    new THREE19.Quaternion(rotation.x, rotation.y, rotation.z, rotation.w)
   );
   transform.rotation.x = euler.x;
   transform.rotation.y = euler.y;
@@ -1199,7 +1213,8 @@ var _PhysicsSyncSystem = class _PhysicsSyncSystem {
         setPhysicsLiveRef(physics, "collider", null);
         continue;
       }
-      const rigidBodySignature = JSON.stringify(physics.values.rigidbody);
+      const { type: _desiredBodyType, ...rigidBodyRebuildValues } = physics.values.rigidbody;
+      const rigidBodySignature = JSON.stringify(rigidBodyRebuildValues);
       const previousRigidBodySignature = this.rigidBodySignatures.get(entityId);
       const hasRigidBody = this.rigidBodyHandles.has(entityId);
       const shouldRecreateBody = !hasRigidBody || previousRigidBodySignature !== rigidBodySignature;
@@ -1226,8 +1241,8 @@ var _PhysicsSyncSystem = class _PhysicsSyncSystem {
           transform.position.y,
           transform.position.z
         );
-        const quaternion = new THREE7.Quaternion().setFromEuler(
-          new THREE7.Euler(
+        const quaternion = new THREE19.Quaternion().setFromEuler(
+          new THREE19.Euler(
             transform.rotation.x,
             transform.rotation.y,
             transform.rotation.z
@@ -1254,6 +1269,25 @@ var _PhysicsSyncSystem = class _PhysicsSyncSystem {
         continue;
       }
       setPhysicsLiveRef(physics, "rigidBody", body);
+      const desiredBodyType = this.isEditorMode ? "fixed" : physics.values.rigidbody.type;
+      const desiredRapierType = toBodyType(this.rapier, desiredBodyType);
+      if (body.bodyType() !== desiredRapierType) {
+        body.setBodyType(desiredRapierType, true);
+        if (!this.isEditorMode && desiredBodyType === "dynamic") {
+          body.setAdditionalMass(physics.values.rigidbody.mass, true);
+        }
+      }
+      const pending = physics.pendingVelocity;
+      if (pending) {
+        setPhysicsLiveRef(physics, "pendingVelocity", null);
+        if (!this.isEditorMode && desiredBodyType === "dynamic") {
+          try {
+            body.setLinvel(pending.linear, true);
+            body.setAngvel(pending.angular, true);
+          } catch {
+          }
+        }
+      }
       if (this.isEditorMode || physics.values.rigidbody.type !== "dynamic") {
         syncBodyFromTransform(body, transform);
       }
@@ -1806,7 +1840,7 @@ function applyLightValues(lightComponent) {
       values.castShadow
     );
   }
-  if (light instanceof THREE7.PointLight) {
+  if (light instanceof THREE19.PointLight) {
     if (typeof values.distance === "number" && Number.isFinite(values.distance)) {
       light.distance = Math.max(MIN_LIGHT_DISTANCE, values.distance);
     }
@@ -1814,7 +1848,7 @@ function applyLightValues(lightComponent) {
       light.decay = Math.max(0, values.decay);
     }
   }
-  if (light instanceof THREE7.SpotLight) {
+  if (light instanceof THREE19.SpotLight) {
     if (typeof values.distance === "number" && Number.isFinite(values.distance)) {
       light.distance = Math.max(MIN_LIGHT_DISTANCE, values.distance);
     }
@@ -1828,7 +1862,7 @@ function applyLightValues(lightComponent) {
       light.penumbra = Math.max(0, Math.min(1, values.penumbra));
     }
   }
-  if (light instanceof THREE7.RectAreaLight) {
+  if (light instanceof THREE19.RectAreaLight) {
     if (typeof values.width === "number" && Number.isFinite(values.width)) {
       light.width = Math.max(MIN_AREA_SIZE, values.width);
     }
@@ -1889,15 +1923,15 @@ function resolveMaterialPropertyKey(key) {
 __name(resolveMaterialPropertyKey, "resolveMaterialPropertyKey");
 function createMaterialByType(type) {
   if (type === "basic") {
-    return new THREE7.MeshBasicMaterial();
+    return new THREE19.MeshBasicMaterial();
   }
   if (type === "phong") {
-    return new THREE7.MeshPhongMaterial();
+    return new THREE19.MeshPhongMaterial();
   }
   if (type === "physical") {
-    return new THREE7.MeshPhysicalMaterial();
+    return new THREE19.MeshPhysicalMaterial();
   }
-  return new THREE7.MeshStandardMaterial();
+  return new THREE19.MeshStandardMaterial();
 }
 __name(createMaterialByType, "createMaterialByType");
 function replaceMaterialAcrossObject(object, previous, next) {
@@ -1956,12 +1990,12 @@ function applyTextureFiltering(material, filtering) {
   const target = material;
   for (const slot of materialTextureSlots) {
     const texture = target[slot];
-    if (!texture || !(texture instanceof THREE7.Texture)) {
+    if (!texture || !(texture instanceof THREE19.Texture)) {
       continue;
     }
     const useMipmaps = texture.generateMipmaps !== false;
-    texture.magFilter = sharp ? THREE7.NearestFilter : THREE7.LinearFilter;
-    texture.minFilter = useMipmaps ? sharp ? THREE7.NearestMipmapNearestFilter : THREE7.LinearMipmapLinearFilter : sharp ? THREE7.NearestFilter : THREE7.LinearFilter;
+    texture.magFilter = sharp ? THREE19.NearestFilter : THREE19.LinearFilter;
+    texture.minFilter = useMipmaps ? sharp ? THREE19.NearestMipmapNearestFilter : THREE19.LinearMipmapLinearFilter : sharp ? THREE19.NearestFilter : THREE19.LinearFilter;
     texture.needsUpdate = true;
   }
   material.needsUpdate = true;
@@ -1971,12 +2005,12 @@ function setTextureMipmaps(material, enabled) {
   const target = material;
   for (const slot of materialTextureSlots) {
     const texture = target[slot];
-    if (!texture || !(texture instanceof THREE7.Texture)) {
+    if (!texture || !(texture instanceof THREE19.Texture)) {
       continue;
     }
     texture.generateMipmaps = enabled;
-    const sharp = texture.magFilter === THREE7.NearestFilter;
-    texture.minFilter = enabled ? sharp ? THREE7.NearestMipmapNearestFilter : THREE7.LinearMipmapLinearFilter : sharp ? THREE7.NearestFilter : THREE7.LinearFilter;
+    const sharp = texture.magFilter === THREE19.NearestFilter;
+    texture.minFilter = enabled ? sharp ? THREE19.NearestMipmapNearestFilter : THREE19.LinearMipmapLinearFilter : sharp ? THREE19.NearestFilter : THREE19.LinearFilter;
     texture.needsUpdate = true;
   }
   material.needsUpdate = true;
@@ -1987,7 +2021,7 @@ function assignMaterialTexture(material, rawKey, url, textureCache) {
   const key = resolveMaterialPropertyKey(rawKey);
   let texture = textureCache.get(url);
   if (!texture) {
-    texture = new THREE7.TextureLoader().load(url);
+    texture = new THREE19.TextureLoader().load(url);
     textureCache.set(url, texture);
   }
   target[key] = texture;
@@ -2025,7 +2059,7 @@ function applyMaterialState(material, value, textureCache) {
   }
   target.side = value.side;
   target.blending = value.blending;
-  target.premultipliedAlpha = value.blending === THREE7.MultiplyBlending || value.blending === THREE7.SubtractiveBlending;
+  target.premultipliedAlpha = value.blending === THREE19.MultiplyBlending || value.blending === THREE19.SubtractiveBlending;
   target.depthTest = value.depthTest;
   target.depthWrite = value.depthWrite;
   target.wireframe = value.wireframe;
@@ -2186,12 +2220,12 @@ function resolvePrimaryMesh(object) {
   if (!object) {
     return null;
   }
-  if (object instanceof THREE7.Mesh) {
+  if (object instanceof THREE19.Mesh) {
     return object;
   }
   let found = null;
   object.traverse((child) => {
-    if (!found && child instanceof THREE7.Mesh) {
+    if (!found && child instanceof THREE19.Mesh) {
       found = child;
     }
   });
@@ -2212,22 +2246,22 @@ function applyGeometry(component) {
   switch (component.kind) {
     case "cube": {
       const params = sanitized;
-      nextGeometry = new THREE7.BoxGeometry(params.width, params.height, params.depth);
+      nextGeometry = new THREE19.BoxGeometry(params.width, params.height, params.depth);
       break;
     }
     case "plane": {
       const params = sanitized;
-      nextGeometry = new THREE7.PlaneGeometry(params.width, params.height);
+      nextGeometry = new THREE19.PlaneGeometry(params.width, params.height);
       break;
     }
     case "sphere": {
       const params = sanitized;
-      nextGeometry = new THREE7.SphereGeometry(params.radius, 24, 24);
+      nextGeometry = new THREE19.SphereGeometry(params.radius, 24, 24);
       break;
     }
     case "cylinder": {
       const params = sanitized;
-      nextGeometry = new THREE7.CylinderGeometry(
+      nextGeometry = new THREE19.CylinderGeometry(
         params.radius,
         params.radius,
         params.height,
@@ -2237,7 +2271,7 @@ function applyGeometry(component) {
     }
     case "capsule": {
       const params = sanitized;
-      nextGeometry = new THREE7.CapsuleGeometry(params.radius, params.height, 4, 8);
+      nextGeometry = new THREE19.CapsuleGeometry(params.radius, params.height, 4, 8);
       break;
     }
     default:
@@ -2253,7 +2287,7 @@ function applyShadowFlags(component) {
     return;
   }
   component.object.traverse((child) => {
-    if (child instanceof THREE7.Mesh) {
+    if (child instanceof THREE19.Mesh) {
       child.castShadow = component.castShadow;
       child.receiveShadow = component.receiveShadow;
     }
@@ -2336,35 +2370,35 @@ function buildGeometry(component) {
   switch (component.meshKind) {
     case "cube": {
       const params = p;
-      return new THREE7.BoxGeometry(params.width, params.height, params.depth);
+      return new THREE19.BoxGeometry(params.width, params.height, params.depth);
     }
     case "plane": {
       const params = p;
-      return new THREE7.PlaneGeometry(params.width, params.height);
+      return new THREE19.PlaneGeometry(params.width, params.height);
     }
     case "sphere": {
       const params = p;
-      return new THREE7.SphereGeometry(params.radius, 24, 24);
+      return new THREE19.SphereGeometry(params.radius, 24, 24);
     }
     case "cylinder": {
       const params = p;
-      return new THREE7.CylinderGeometry(params.radius, params.radius, params.height, 20);
+      return new THREE19.CylinderGeometry(params.radius, params.radius, params.height, 20);
     }
     case "capsule": {
       const params = p;
-      return new THREE7.CapsuleGeometry(params.radius, params.height, 4, 8);
+      return new THREE19.CapsuleGeometry(params.radius, params.height, 4, 8);
     }
     default:
-      return new THREE7.BoxGeometry(1, 1, 1);
+      return new THREE19.BoxGeometry(1, 1, 1);
   }
 }
 __name(buildGeometry, "buildGeometry");
-var _position = new THREE7.Vector3();
-var _quaternion = new THREE7.Quaternion();
-var _euler = new THREE7.Euler();
-var _scale = new THREE7.Vector3();
-var _matrix = new THREE7.Matrix4();
-var _modelMatrix = new THREE7.Matrix4();
+var _position = new THREE19.Vector3();
+var _quaternion = new THREE19.Quaternion();
+var _euler = new THREE19.Euler();
+var _scale = new THREE19.Vector3();
+var _matrix = new THREE19.Matrix4();
+var _modelMatrix = new THREE19.Matrix4();
 function instanceTransformFromComponent(transform, out) {
   _position.set(transform.position.x, transform.position.y, transform.position.z);
   _euler.set(transform.rotation.x, transform.rotation.y, transform.rotation.z, "XYZ");
@@ -2517,7 +2551,7 @@ var _InstancedMeshSystem = class _InstancedMeshSystem {
                 const sourceMaterial = Array.isArray(meshChild.material) ? meshChild.material.map((m) => m.clone()) : meshChild.material.clone();
                 meshChild.updateWorldMatrix(true, false);
                 const localMatrix = meshChild.matrixWorld.clone();
-                const instancedMesh2 = new THREE7.InstancedMesh(
+                const instancedMesh2 = new THREE19.InstancedMesh(
                   geometry2,
                   Array.isArray(sourceMaterial) ? sourceMaterial : sourceMaterial,
                   count2
@@ -2542,7 +2576,7 @@ var _InstancedMeshSystem = class _InstancedMeshSystem {
                 this.loadingSignatures.delete(targetEntityId);
                 return;
               }
-              const group = new THREE7.Group();
+              const group = new THREE19.Group();
               for (const entry of entries) {
                 group.add(entry.instancedMesh);
               }
@@ -2560,8 +2594,8 @@ var _InstancedMeshSystem = class _InstancedMeshSystem {
         }
         const count = instanceCount;
         const geometry = buildGeometry(comp);
-        const material = new THREE7.MeshStandardMaterial({ color: "#ffffff" });
-        const instancedMesh = new THREE7.InstancedMesh(geometry, material, count);
+        const material = new THREE19.MeshStandardMaterial({ color: "#ffffff" });
+        const instancedMesh = new THREE19.InstancedMesh(geometry, material, count);
         instancedMesh.castShadow = comp.castShadow;
         instancedMesh.receiveShadow = comp.receiveShadow;
         for (let i = 0; i < count; i++) {
@@ -2981,9 +3015,6 @@ function restorePostCreateComponents(world, objectManagementSystem, targetEntity
       if (typeof sourceInteractable.pointable === "boolean") {
         interactable.pointable = sourceInteractable.pointable;
       }
-      if (typeof sourceInteractable.grabMode === "string") {
-        interactable.grabMode = sourceInteractable.grabMode;
-      }
       if (typeof sourceInteractable.grabReach === "string") {
         interactable.grabReach = sourceInteractable.grabReach;
       }
@@ -2996,6 +3027,30 @@ function restorePostCreateComponents(world, objectManagementSystem, targetEntity
       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.throwOnRelease === "boolean") {
         interactable.throwOnRelease = sourceInteractable.throwOnRelease;
       }
@@ -3018,8 +3073,16 @@ function restorePostCreateComponents(world, objectManagementSystem, targetEntity
           z: typeof grabRot.z === "number" ? grabRot.z : 0
         };
       }
-      if (typeof sourceInteractable.highlightOnHover === "boolean") {
-        interactable.highlightOnHover = sourceInteractable.highlightOnHover;
+      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;
       }
     }
   }
@@ -4747,7 +4810,7 @@ var _Behaviour = class _Behaviour {
     if (!this.threeRef) {
       return null;
     }
-    const position = new THREE7.Vector3();
+    const position = new THREE19.Vector3();
     this.threeRef.object.getWorldPosition(position);
     return position;
   }
@@ -4759,7 +4822,7 @@ var _Behaviour = class _Behaviour {
     if (!this.threeRef) {
       return null;
     }
-    const target = new THREE7.Vector3();
+    const target = new THREE19.Vector3();
     this.threeRef.object.getWorldDirection(target);
     return target;
   }
@@ -4821,7 +4884,7 @@ var _Behaviour = class _Behaviour {
     if (!this.threeRef) {
       return;
     }
-    const rotation = new THREE7.Quaternion();
+    const rotation = new THREE19.Quaternion();
     this.threeRef.object.getWorldQuaternion(rotation);
     rotation.slerp(targetRotation, alpha);
     this.transform.setRotation(rotation);
@@ -4838,7 +4901,7 @@ var _Behaviour = class _Behaviour {
       return;
     }
     const clone2 = this.threeRef.object.clone();
-    const rotation = new THREE7.Quaternion();
+    const rotation = new THREE19.Quaternion();
     clone2.lookAt(targetPosition);
     clone2.getWorldQuaternion(rotation);
     this.transform.setRotation(rotation);
@@ -4976,6 +5039,17 @@ var _Behaviour = class _Behaviour {
    *
    * @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) {
+  }
   /**
    * A hand pose declared on this entity started being held.
    *
@@ -5193,8 +5267,8 @@ var _ScriptBehaviourSystem = class _ScriptBehaviourSystem {
     }, "onPointerUp");
     this.moduleLoader = moduleLoader ?? defaultModuleLoader;
     this.selectionCtx = selectionContext ?? null;
-    this.raycaster = new THREE7.Raycaster();
-    this.ndcPointer = new THREE7.Vector2();
+    this.raycaster = new THREE19.Raycaster();
+    this.ndcPointer = new THREE19.Vector2();
     if (this.selectionCtx) {
       this.selectionCtx.domElement.addEventListener("pointerdown", this.onPointerDown);
       this.selectionCtx.domElement.addEventListener("pointerup", this.onPointerUp);
@@ -5573,7 +5647,7 @@ function disposeBuiltObject(root) {
     for (const mat of materials) {
       if (mat.userData?.[SHARED_MODEL_RESOURCE_FLAG]) continue;
       for (const value of Object.values(mat)) {
-        if (value instanceof THREE7.Texture) value.dispose();
+        if (value instanceof THREE19.Texture) value.dispose();
       }
       mat.dispose?.();
     }
@@ -5937,7 +6011,7 @@ var _AudioSystem = class _AudioSystem {
     if (!prev || prev.volume !== opts.volume) {
       sound.setVolume(opts.volume);
     }
-    if (opts.positional && sound instanceof THREE7.PositionalAudio) {
+    if (opts.positional && sound instanceof THREE19.PositionalAudio) {
       if (!prev || prev.refDistance !== opts.refDistance) {
         sound.setRefDistance(opts.refDistance);
       }
@@ -6063,7 +6137,7 @@ var _VideoSystem = class _VideoSystem {
       component.object.scale.set(opts.width, opts.height, 1);
     }
     const material = component.material;
-    if (material instanceof THREE7.ShaderMaterial) {
+    if (material instanceof THREE19.ShaderMaterial) {
       if (!prev || prev.backgroundColor !== opts.backgroundColor) {
         material.uniforms.keyColor.value.set(opts.backgroundColor);
       }
@@ -6077,7 +6151,7 @@ var _VideoSystem = class _VideoSystem {
         material.uniforms.spill.value = opts.spill;
       }
     }
-    if (opts.positional && component.audioNode instanceof THREE7.PositionalAudio) {
+    if (opts.positional && component.audioNode instanceof THREE19.PositionalAudio) {
       const posAudio = component.audioNode;
       if (!prev || prev.refDistance !== opts.refDistance) {
         posAudio.setRefDistance(opts.refDistance);
@@ -6117,8 +6191,8 @@ function blankState(source) {
     handedness: handednessOf(source),
     kind: kindOf(source),
     connected: true,
-    rayOrigin: new THREE7.Vector3(),
-    rayDirection: new THREE7.Vector3(0, 0, -1),
+    rayOrigin: new THREE19.Vector3(),
+    rayDirection: new THREE19.Vector3(0, 0, -1),
     gripPosition: null,
     gripQuaternion: null,
     select: false,
@@ -6144,7 +6218,7 @@ function readHandJoints(frame, hand, referenceSpace, rigMatrix, existing) {
   }
   if (spaces.length === 0) return null;
   const target = existing ?? {};
-  const matrix = new THREE7.Matrix4();
+  const matrix = new THREE19.Matrix4();
   const buffer = spaces.length * 16 <= JOINT_MATRIX_BUFFER.length ? JOINT_MATRIX_BUFFER : new Float32Array(spaces.length * 16);
   const fillPoses = frame.fillPoses;
   if (typeof fillPoses === "function") {
@@ -6157,7 +6231,7 @@ function readHandJoints(frame, hand, referenceSpace, rigMatrix, existing) {
     if (filled) {
       for (let i = 0; i < names.length; i += 1) {
         matrix.fromArray(buffer, i * 16).premultiply(rigMatrix);
-        const vector = target[names[i]] ?? new THREE7.Vector3();
+        const vector = target[names[i]] ?? new THREE19.Vector3();
         vector.setFromMatrixPosition(matrix);
         target[names[i]] = vector;
       }
@@ -6175,7 +6249,7 @@ function readHandJoints(frame, hand, referenceSpace, rigMatrix, existing) {
       continue;
     }
     matrix.fromArray(pose.transform.matrix).premultiply(rigMatrix);
-    const vector = target[names[i]] ?? new THREE7.Vector3();
+    const vector = target[names[i]] ?? new THREE19.Vector3();
     vector.setFromMatrixPosition(matrix);
     target[names[i]] = vector;
     anyTracked = true;
@@ -6187,7 +6261,7 @@ var _XRInputSystem = class _XRInputSystem {
   constructor() {
     this.records = /* @__PURE__ */ new Map();
     /** Reference-space → world matrix, rebuilt each frame from the XR rig. */
-    this.referenceToWorld = new THREE7.Matrix4();
+    this.referenceToWorld = new THREE19.Matrix4();
     this.session = null;
     this.onSelectStart = /* @__PURE__ */ __name((event) => this.mark(event, "pendingSelectStart"), "onSelectStart");
     this.onSelectEnd = /* @__PURE__ */ __name((event) => this.mark(event, "pendingSelectEnd"), "onSelectEnd");
@@ -6285,19 +6359,19 @@ var _XRInputSystem = class _XRInputSystem {
       if (frame && referenceSpace && source.targetRaySpace) {
         const pose = frame.getPose(source.targetRaySpace, referenceSpace);
         if (pose) {
-          const m = new THREE7.Matrix4().fromArray(pose.transform.matrix).premultiply(rigMatrix);
+          const m = new THREE19.Matrix4().fromArray(pose.transform.matrix).premultiply(rigMatrix);
           state.rayOrigin.setFromMatrixPosition(m);
           state.rayDirection.set(0, 0, -1).applyQuaternion(
-            new THREE7.Quaternion().setFromRotationMatrix(m)
+            new THREE19.Quaternion().setFromRotationMatrix(m)
           ).normalize();
         }
       }
       if (frame && referenceSpace && source.gripSpace) {
         const gripPose = frame.getPose(source.gripSpace, referenceSpace);
         if (gripPose) {
-          const m = new THREE7.Matrix4().fromArray(gripPose.transform.matrix).premultiply(rigMatrix);
-          state.gripPosition ?? (state.gripPosition = new THREE7.Vector3());
-          state.gripQuaternion ?? (state.gripQuaternion = new THREE7.Quaternion());
+          const m = new THREE19.Matrix4().fromArray(gripPose.transform.matrix).premultiply(rigMatrix);
+          state.gripPosition ?? (state.gripPosition = new THREE19.Vector3());
+          state.gripQuaternion ?? (state.gripQuaternion = new THREE19.Quaternion());
           state.gripPosition.setFromMatrixPosition(m);
           state.gripQuaternion.setFromRotationMatrix(m);
         }
@@ -6406,15 +6480,15 @@ var _ThrowVelocityTracker = class _ThrowVelocityTracker {
     const fresh = this.samples.filter(
       (sample) => now - sample.time <= MAX_SAMPLE_AGE_SECONDS
     );
-    if (fresh.length < 2) return new THREE7.Vector3();
-    let best = new THREE7.Vector3();
+    if (fresh.length < 2) return new THREE19.Vector3();
+    let best = new THREE19.Vector3();
     let bestSpeed = 0;
     for (let i = 1; i < fresh.length; i += 1) {
       const previous = fresh[i - 1];
       const current = fresh[i];
       const dt = current.time - previous.time;
       if (dt <= 1e-5) continue;
-      const velocity = new THREE7.Vector3().subVectors(current.position, previous.position).divideScalar(dt);
+      const velocity = new THREE19.Vector3().subVectors(current.position, previous.position).divideScalar(dt);
       const speed = velocity.length();
       if (speed > MAX_PLAUSIBLE_SPEED) continue;
       if (speed > bestSpeed) {
@@ -6431,25 +6505,79 @@ var _ThrowVelocityTracker = class _ThrowVelocityTracker {
 __name(_ThrowVelocityTracker, "ThrowVelocityTracker");
 var ThrowVelocityTracker = _ThrowVelocityTracker;
 function angularVelocityFrom(previous, current, deltaTime) {
-  if (deltaTime <= 1e-5) return new THREE7.Vector3();
+  if (deltaTime <= 1e-5) return new THREE19.Vector3();
   const delta = current.clone().multiply(previous.clone().invert());
   if (delta.w < 0) {
     delta.set(-delta.x, -delta.y, -delta.z, -delta.w);
   }
-  const angle = 2 * Math.acos(THREE7.MathUtils.clamp(delta.w, -1, 1));
+  const angle = 2 * Math.acos(THREE19.MathUtils.clamp(delta.w, -1, 1));
   const sinHalf = Math.sqrt(Math.max(0, 1 - delta.w * delta.w));
-  if (sinHalf < 1e-6 || angle < 1e-6) return new THREE7.Vector3();
-  return new THREE7.Vector3(delta.x, delta.y, delta.z).divideScalar(sinHalf).multiplyScalar(angle / deltaTime);
+  if (sinHalf < 1e-6 || angle < 1e-6) return new THREE19.Vector3();
+  return new THREE19.Vector3(delta.x, delta.y, delta.z).divideScalar(sinHalf).multiplyScalar(angle / deltaTime);
 }
 __name(angularVelocityFrom, "angularVelocityFrom");
+var MIN_HAND_SEPARATION = 0.06;
+var MIN_ANCHOR_SEPARATION = 1e-3;
+var SCALE_DEADZONE = 0.05;
+function solveTwoHandTransform(primary, secondary, basis, options) {
+  const separation = primary.position.distanceTo(secondary.position);
+  const anchorDelta = new THREE19.Vector3().subVectors(
+    basis.secondaryLocal,
+    basis.primaryLocal
+  );
+  const anchorLength = anchorDelta.length();
+  let factor = 1;
+  if (options.allowScale && basis.initialSeparation > MIN_ANCHOR_SEPARATION && separation > MIN_ANCHOR_SEPARATION) {
+    factor = separation / basis.initialSeparation;
+    if (Math.abs(factor - 1) <= SCALE_DEADZONE) {
+      factor = 1;
+    } else {
+      factor += factor > 1 ? -SCALE_DEADZONE : SCALE_DEADZONE;
+    }
+    factor = Math.min(options.maxScale, Math.max(options.minScale, factor));
+  }
+  const scale = basis.initialScale.clone().multiplyScalar(factor);
+  const degenerate = separation < MIN_HAND_SEPARATION || anchorLength < MIN_ANCHOR_SEPARATION;
+  const base = primary.quaternion.clone().multiply(basis.primaryHandOffset);
+  let quaternion;
+  if (options.rotationMode === "primary" || degenerate) {
+    quaternion = base;
+  } else {
+    const axisLocal = anchorDelta.clone().normalize();
+    const currentAxis = axisLocal.clone().applyQuaternion(base).normalize();
+    const desiredAxis = new THREE19.Vector3().subVectors(secondary.position, primary.position).normalize();
+    const correction = new THREE19.Quaternion().setFromUnitVectors(
+      currentAxis,
+      desiredAxis
+    );
+    quaternion = correction.multiply(base);
+  }
+  const anchorOffset = basis.primaryLocal.clone().multiply(scale).applyQuaternion(quaternion);
+  const position = primary.position.clone().sub(anchorOffset);
+  return { position, quaternion, scale, degenerate };
+}
+__name(solveTwoHandTransform, "solveTwoHandTransform");
 
 // core/systems/XRInteractionSystem.ts
 var RAYLESS_HOLD_DISTANCE = 0.5;
+function quatFromEulerVec(r) {
+  return new THREE19.Quaternion().setFromEuler(new THREE19.Euler(r.x, r.y, r.z));
+}
+__name(quatFromEulerVec, "quatFromEulerVec");
+function writeEuler(target, q) {
+  const euler = new THREE19.Euler().setFromQuaternion(q);
+  target.x = euler.x;
+  target.y = euler.y;
+  target.z = euler.z;
+}
+__name(writeEuler, "writeEuler");
 var _XRInteractionSystem = class _XRInteractionSystem {
   constructor(inputSystem) {
-    this.raycaster = new THREE7.Raycaster();
+    this.raycaster = new THREE19.Raycaster();
     this.grabs = /* @__PURE__ */ new Map();
     this.hoveredEntityId = null;
+    /** Per-hand hover, with the hit distance so the ray can stop at the surface. */
+    this.hovers = /* @__PURE__ */ new Map();
     /** Monotonic seconds, accumulated from deltaTime for velocity sampling. */
     this.elapsed = 0;
     this.inputSystem = inputSystem;
@@ -6463,6 +6591,7 @@ var _XRInteractionSystem = class _XRInteractionSystem {
     const inputs = this.inputSystem.getInputs();
     const interactables = this.collectInteractables(world);
     this.hoveredEntityId = null;
+    this.hovers.clear();
     for (const input of inputs) {
       if (!input.connected) {
         this.release(world, input);
@@ -6470,7 +6599,6 @@ var _XRInteractionSystem = class _XRInteractionSystem {
       }
       const held = this.grabs.get(input);
       if (held) {
-        this.moveHeld(world, input, held, deltaTime);
         if (this.wantsRelease(world, input, held)) {
           this.release(world, input);
         }
@@ -6481,6 +6609,10 @@ var _XRInteractionSystem = class _XRInteractionSystem {
       if (this.hoveredEntityId === null) {
         this.hoveredEntityId = candidate.entityId;
       }
+      this.hovers.set(input, {
+        entityId: candidate.entityId,
+        distance: candidate.distance
+      });
       const interactable = world.getComponent(
         candidate.entityId,
         XRInteractableComponent
@@ -6491,9 +6623,122 @@ var _XRInteractionSystem = class _XRInteractionSystem {
         /* starting */
         true
       )) {
-        this.grab(world, input, candidate.entityId, candidate.viaDistance);
+        this.tryGrab(world, input, candidate.entityId, candidate.viaDistance);
       }
     }
+    this.moveAllHeld(world, deltaTime);
+  }
+  /** Hands currently holding an entity. */
+  holdersOf(entityId) {
+    const holders = [];
+    for (const [input, record] of this.grabs) {
+      if (record.entityId === entityId) holders.push({ input, record });
+    }
+    return holders;
+  }
+  /**
+   * Route a new grab: first hand, hand-off, or second hand.
+   *
+   * Which of those happens is the object's choice (`grabHands`), not the
+   * hand's — a ball should pass between hands, a rifle should be held by both,
+   * and a lever should stay with whoever grabbed it first.
+   */
+  tryGrab(world, input, entityId, viaDistance) {
+    const interactable = world.getComponent(entityId, XRInteractableComponent);
+    if (!interactable) return;
+    const holders = this.holdersOf(entityId);
+    if (holders.length === 0) {
+      this.grab(world, input, entityId, viaDistance, "primary");
+      return;
+    }
+    if (holders.some((holder) => holder.input === input)) return;
+    if (interactable.grabHands === "single") return;
+    if (interactable.grabHands === "handOff") {
+      const previous = holders[0];
+      this.grabs.delete(previous.input);
+      const record = previous.record;
+      record.role = "primary";
+      record.twoHand = null;
+      this.reanchor(world, input, record, interactable);
+      this.grabs.set(input, record);
+      this.dispatch(world, entityId, (b) => b.onGrab(input));
+      return;
+    }
+    if (holders.length >= 2) return;
+    this.grab(world, input, entityId, viaDistance, "secondary");
+    this.beginTwoHand(world, entityId);
+  }
+  /**
+   * Re-derive a record's hold from where the object is NOW.
+   *
+   * Used on hand-off and on promotion after the primary lets go. Without it the
+   * object snaps to whatever offset the previous hand had, which reads as the
+   * object jumping out of your grip at the moment you take it.
+   */
+  reanchor(world, input, record, interactable) {
+    const transform = world.getComponent(record.entityId, TransformComponent);
+    if (!transform) return;
+    const hand = this.handPosition(input);
+    const handQuaternion = this.handQuaternion(input);
+    const objectQuaternion = quatFromEulerVec(transform.rotation);
+    record.offset = new THREE19.Vector3(
+      transform.position.x - hand.x,
+      transform.position.y - hand.y,
+      transform.position.z - hand.z
+    ).applyQuaternion(handQuaternion.clone().invert());
+    record.handRotationOffset = handQuaternion.clone().invert().multiply(objectQuaternion);
+    record.remote = false;
+    record.tracker.clear();
+    record.tracker.record(hand, this.elapsed);
+    record.lastHandQuaternion = handQuaternion.clone();
+    if (record.attachLocal && interactable.attachPoints.length === 0) {
+      record.attachLocal = null;
+      record.attachQuaternion = null;
+      record.attachPointId = null;
+    }
+  }
+  /** Capture the two-hand basis once both hands are on the object. */
+  beginTwoHand(world, entityId) {
+    const holders = this.holdersOf(entityId);
+    if (holders.length !== 2) return;
+    const primary = holders.find((h) => h.record.role === "primary");
+    const secondary = holders.find((h) => h.record.role === "secondary");
+    if (!primary || !secondary) return;
+    const transform = world.getComponent(entityId, TransformComponent);
+    if (!transform) return;
+    const primaryHand = this.handPosition(primary.input);
+    const secondaryHand = this.handPosition(secondary.input);
+    const primaryLocal = primary.record.attachLocal?.clone() ?? this.objectLocalPoint(transform, primaryHand);
+    const secondaryLocal = secondary.record.attachLocal?.clone() ?? this.objectLocalPoint(transform, secondaryHand);
+    primary.record.twoHand = {
+      primaryLocal,
+      secondaryLocal,
+      initialScale: new THREE19.Vector3(
+        transform.scale.x,
+        transform.scale.y,
+        transform.scale.z
+      ),
+      initialSeparation: primaryHand.distanceTo(secondaryHand),
+      // How the object sits relative to the anchoring hand right now, so the
+      // two-hand solve picks up exactly where the one-hand hold left off.
+      primaryHandOffset: this.handQuaternion(primary.input).invert().multiply(quatFromEulerVec(transform.rotation)),
+      initialQuaternion: quatFromEulerVec(transform.rotation)
+    };
+    this.dispatch(world, entityId, (b) => b.onSecondaryGrab(secondary.input));
+  }
+  /** World point → the object's UNSCALED local space. */
+  objectLocalPoint(transform, worldPoint) {
+    const local = worldPoint.clone().sub(
+      new THREE19.Vector3(
+        transform.position.x,
+        transform.position.y,
+        transform.position.z
+      )
+    ).applyQuaternion(quatFromEulerVec(transform.rotation).invert());
+    local.x /= transform.scale.x || 1;
+    local.y /= transform.scale.y || 1;
+    local.z /= transform.scale.z || 1;
+    return local;
   }
   /** Whether the grab gesture for this object is currently starting. */
   gestureMatches(input, interactable, starting) {
@@ -6542,7 +6787,7 @@ var _XRInteractionSystem = class _XRInteractionSystem {
       );
       if (!interactable2) continue;
       if (interactable2.grabReach === "distance") continue;
-      const position = new THREE7.Vector3();
+      const position = new THREE19.Vector3();
       entry.object.getWorldPosition(position);
       const distance = position.distanceTo(hand);
       if (distance <= interactable2.grabRadius && distance < nearestDistance) {
@@ -6551,13 +6796,22 @@ var _XRInteractionSystem = class _XRInteractionSystem {
       }
     }
     if (nearestId !== null) {
-      return { entityId: nearestId, viaDistance: false };
+      return {
+        entityId: nearestId,
+        viaDistance: false,
+        distance: nearestDistance
+      };
     }
-    const hitId = this.raycast(input, interactables);
-    if (hitId === null) return null;
+    const hit = this.raycast(input, interactables);
+    if (hit === null) return null;
+    const hitId = hit.entityId;
     const interactable = world.getComponent(hitId, XRInteractableComponent);
     const viaDistanceAllowed = interactable?.grabReach === "distance" || interactable?.grabReach === "both";
-    return { entityId: hitId, viaDistance: viaDistanceAllowed };
+    return {
+      entityId: hitId,
+      viaDistance: viaDistanceAllowed,
+      distance: hit.distance
+    };
   }
   collectInteractables(world) {
     const out = [];
@@ -6588,9 +6842,54 @@ var _XRInteractionSystem = class _XRInteractionSystem {
         nearestId = entry.entityId;
       }
     }
-    return nearestId;
+    return nearestId === null ? null : { entityId: nearestId, distance: nearestDistance };
+  }
+  /**
+   * Pick the authored hold this hand should take.
+   *
+   * Filters by hand and by role — that is what makes "the trigger hand goes on
+   * the grip" hold regardless of which hand reaches first — then takes the
+   * nearest remaining one so grabbing near the foregrip picks the foregrip.
+   */
+  chooseAttachPoint(world, input, entityId, interactable, role) {
+    if (interactable.attachPoints.length === 0) return null;
+    const transform = world.getComponent(entityId, TransformComponent);
+    if (!transform) return null;
+    const taken = new Set(
+      this.holdersOf(entityId).map((holder) => holder.record.attachPointId).filter((id) => id !== null)
+    );
+    const hand = this.handPosition(input);
+    const objectPosition = new THREE19.Vector3(
+      transform.position.x,
+      transform.position.y,
+      transform.position.z
+    );
+    const objectQuaternion = quatFromEulerVec(transform.rotation);
+    const scale = new THREE19.Vector3(
+      transform.scale.x,
+      transform.scale.y,
+      transform.scale.z
+    );
+    let best = null;
+    let bestDistance = Number.POSITIVE_INFINITY;
+    for (const point of interactable.attachPoints) {
+      if (taken.has(point.id)) continue;
+      if (point.hand !== "any" && point.hand !== input.handedness) continue;
+      if (point.role !== "any" && point.role !== role) continue;
+      const world3 = new THREE19.Vector3(
+        point.position.x,
+        point.position.y,
+        point.position.z
+      ).multiply(scale).applyQuaternion(objectQuaternion).add(objectPosition);
+      const distance = world3.distanceTo(hand);
+      if (distance < bestDistance) {
+        bestDistance = distance;
+        best = point;
+      }
+    }
+    return best;
   }
-  grab(world, input, entityId, viaDistance) {
+  grab(world, input, entityId, viaDistance, role) {
     const transform = world.getComponent(entityId, TransformComponent);
     const interactable = world.getComponent(entityId, XRInteractableComponent);
     if (!transform || !interactable) return;
@@ -6600,25 +6899,25 @@ var _XRInteractionSystem = class _XRInteractionSystem {
     let offset;
     let remoteDistance = 0;
     if (remote) {
-      const position = new THREE7.Vector3(
+      const position = new THREE19.Vector3(
         transform.position.x,
         transform.position.y,
         transform.position.z
       );
       remoteDistance = position.distanceTo(input.rayOrigin);
-      offset = new THREE7.Vector3();
+      offset = new THREE19.Vector3();
     } else if (viaDistance) {
-      offset = new THREE7.Vector3(
+      offset = new THREE19.Vector3(
         interactable.grabOffsetPosition.x,
         interactable.grabOffsetPosition.y,
         interactable.grabOffsetPosition.z
       );
     } else {
-      offset = new THREE7.Vector3(
+      offset = new THREE19.Vector3(
         transform.position.x - hand.x,
         transform.position.y - hand.y,
         transform.position.z - hand.z
-      );
+      ).applyQuaternion(handQuaternion.clone().invert());
     }
     const physics = world.getComponent(entityId, PhysicsComponent);
     let restoreBodyType = null;
@@ -6628,11 +6927,30 @@ var _XRInteractionSystem = class _XRInteractionSystem {
     }
     const tracker = new ThrowVelocityTracker();
     tracker.record(hand, this.elapsed);
+    const attachPoint = this.chooseAttachPoint(
+      world,
+      input,
+      entityId,
+      interactable,
+      role
+    );
+    const objectQuaternion = quatFromEulerVec(transform.rotation);
+    const handRotationOffset = handQuaternion.clone().invert().multiply(objectQuaternion);
     this.grabs.set(input, {
       entityId,
+      role,
+      attachPointId: attachPoint?.id ?? null,
+      attachLocal: attachPoint ? new THREE19.Vector3(
+        attachPoint.position.x,
+        attachPoint.position.y,
+        attachPoint.position.z
+      ) : null,
+      attachQuaternion: attachPoint ? quatFromEulerVec(attachPoint.rotation) : null,
+      handRotationOffset,
+      twoHand: null,
       offset,
-      rotationOffset: new THREE7.Quaternion().setFromEuler(
-        new THREE7.Euler(
+      rotationOffset: new THREE19.Quaternion().setFromEuler(
+        new THREE19.Euler(
           interactable.grabOffsetRotation.x,
           interactable.grabOffsetRotation.y,
           interactable.grabOffsetRotation.z
@@ -6643,33 +6961,111 @@ var _XRInteractionSystem = class _XRInteractionSystem {
       restoreBodyType,
       tracker,
       lastHandQuaternion: handQuaternion.clone(),
-      angularVelocity: new THREE7.Vector3()
+      angularVelocity: new THREE19.Vector3()
     });
-    this.dispatch(world, entityId, (b) => b.onGrab(input));
+    if (role === "primary") {
+      this.dispatch(world, entityId, (b) => b.onGrab(input));
+    }
+  }
+  /** Drive every held object, once each, after grabs and releases settle. */
+  moveAllHeld(world, deltaTime) {
+    const done = /* @__PURE__ */ new Set();
+    for (const [input, record] of this.grabs) {
+      if (done.has(record.entityId)) continue;
+      done.add(record.entityId);
+      const holders = this.holdersOf(record.entityId);
+      if (holders.length >= 2) {
+        this.moveTwoHand(world, record.entityId, holders, deltaTime);
+      } else {
+        this.moveHeld(world, input, record, deltaTime);
+      }
+    }
+  }
+  /** Solve and apply a two-hand hold. */
+  moveTwoHand(world, entityId, holders, deltaTime) {
+    const primary = holders.find((h) => h.record.role === "primary");
+    const secondary = holders.find((h) => h.record.role === "secondary");
+    const transform = world.getComponent(entityId, TransformComponent);
+    const interactable = world.getComponent(entityId, XRInteractableComponent);
+    const basis = primary?.record.twoHand ?? null;
+    if (!primary || !secondary || !transform || !interactable || !basis) {
+      if (primary) {
+        this.moveHeld(world, primary.input, primary.record, deltaTime);
+      }
+      return;
+    }
+    const primaryHand = this.handPosition(primary.input);
+    const primaryQuaternion = this.handQuaternion(primary.input);
+    const solved = solveTwoHandTransform(
+      { position: primaryHand, quaternion: primaryQuaternion },
+      {
+        position: this.handPosition(secondary.input),
+        quaternion: this.handQuaternion(secondary.input)
+      },
+      basis,
+      {
+        rotationMode: interactable.twoHandRotation,
+        allowScale: interactable.allowTwoHandScale,
+        minScale: interactable.minScale,
+        maxScale: interactable.maxScale
+      }
+    );
+    transform.position.x = solved.position.x;
+    transform.position.y = solved.position.y;
+    transform.position.z = solved.position.z;
+    writeEuler(transform.rotation, solved.quaternion);
+    if (interactable.allowTwoHandScale) {
+      transform.scale.x = solved.scale.x;
+      transform.scale.y = solved.scale.y;
+      transform.scale.z = solved.scale.z;
+    }
+    primary.record.tracker.record(primaryHand, this.elapsed);
+    primary.record.angularVelocity = angularVelocityFrom(
+      primary.record.lastHandQuaternion,
+      primaryQuaternion,
+      deltaTime
+    );
+    primary.record.lastHandQuaternion = primaryQuaternion.clone();
   }
   moveHeld(world, input, held, deltaTime) {
     const transform = world.getComponent(held.entityId, TransformComponent);
     if (!transform) return;
     const hand = this.handPosition(input);
+    const handQuaternion = this.handQuaternion(input);
+    const objectQuaternion = held.attachQuaternion ? handQuaternion.clone().multiply(held.rotationOffset).multiply(held.attachQuaternion.clone().invert()) : handQuaternion.clone().multiply(held.handRotationOffset);
     if (held.remote) {
-      const target = new THREE7.Vector3().copy(input.rayDirection).multiplyScalar(held.remoteDistance).add(input.rayOrigin);
+      const target = new THREE19.Vector3().copy(input.rayDirection).multiplyScalar(held.remoteDistance).add(input.rayOrigin);
       transform.position.x = target.x;
       transform.position.y = target.y;
       transform.position.z = target.z;
+      writeEuler(transform.rotation, objectQuaternion);
+    } else if (held.attachLocal) {
+      const anchor = held.attachLocal.clone().multiply(
+        new THREE19.Vector3(
+          transform.scale.x,
+          transform.scale.y,
+          transform.scale.z
+        )
+      ).applyQuaternion(objectQuaternion);
+      transform.position.x = hand.x - anchor.x;
+      transform.position.y = hand.y - anchor.y;
+      transform.position.z = hand.z - anchor.z;
+      writeEuler(transform.rotation, objectQuaternion);
     } else {
-      transform.position.x = hand.x + held.offset.x;
-      transform.position.y = hand.y + held.offset.y;
-      transform.position.z = hand.z + held.offset.z;
+      const carried = held.offset.clone().applyQuaternion(handQuaternion);
+      transform.position.x = hand.x + carried.x;
+      transform.position.y = hand.y + carried.y;
+      transform.position.z = hand.z + carried.z;
+      writeEuler(transform.rotation, objectQuaternion);
     }
     held.tracker.record(
-      held.remote ? new THREE7.Vector3(
+      held.remote ? new THREE19.Vector3(
         transform.position.x,
         transform.position.y,
         transform.position.z
       ) : hand,
       this.elapsed
     );
-    const handQuaternion = this.handQuaternion(input);
     held.angularVelocity = angularVelocityFrom(
       held.lastHandQuaternion,
       handQuaternion,
@@ -6685,22 +7081,41 @@ var _XRInteractionSystem = class _XRInteractionSystem {
       held.entityId,
       XRInteractableComponent
     );
+    const remaining = this.holdersOf(held.entityId);
+    if (remaining.length > 0 && interactable) {
+      if (held.role === "secondary") {
+        const primary = remaining.find((h) => h.record.role === "primary");
+        if (primary) {
+          primary.record.twoHand = null;
+          this.reanchor(world, primary.input, primary.record, interactable);
+        }
+        this.dispatch(
+          world,
+          held.entityId,
+          (b) => b.onSecondaryRelease(input)
+        );
+      } else {
+        const next = remaining[0];
+        next.record.role = "primary";
+        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));
+      }
+      held.tracker.clear();
+      return;
+    }
     const physics = world.getComponent(held.entityId, PhysicsComponent);
     if (held.restoreBodyType !== null && physics) {
       physics.values.rigidbody.type = held.restoreBodyType;
-      const body = physics.rigidBody;
       const dynamic = held.restoreBodyType === "dynamic";
-      if (body && dynamic && interactable?.throwOnRelease) {
+      if (dynamic && interactable?.throwOnRelease) {
         const velocity = held.tracker.computeVelocity(this.elapsed).multiplyScalar(interactable.throwStrength);
-        try {
-          body.setLinvel(
-            { x: velocity.x, y: velocity.y, z: velocity.z },
-            true
-          );
-          const spin = held.angularVelocity;
-          body.setAngvel({ x: spin.x, y: spin.y, z: spin.z }, true);
-        } catch {
-        }
+        const spin = held.angularVelocity;
+        setPhysicsLiveRef(physics, "pendingVelocity", {
+          linear: { x: velocity.x, y: velocity.y, z: velocity.z },
+          angular: { x: spin.x, y: spin.y, z: spin.z }
+        });
       }
     }
     held.tracker.clear();
@@ -6718,7 +7133,7 @@ var _XRInteractionSystem = class _XRInteractionSystem {
    */
   handPosition(input) {
     if (input.gripPosition) return input.gripPosition;
-    return new THREE7.Vector3().copy(input.rayDirection).multiplyScalar(RAYLESS_HOLD_DISTANCE).add(input.rayOrigin);
+    return new THREE19.Vector3().copy(input.rayDirection).multiplyScalar(RAYLESS_HOLD_DISTANCE).add(input.rayOrigin);
   }
   /**
    * Hand orientation. Grip-less sources (gaze / transient-pointer) have none,
@@ -6726,8 +7141,8 @@ var _XRInteractionSystem = class _XRInteractionSystem {
    */
   handQuaternion(input) {
     if (input.gripQuaternion) return input.gripQuaternion.clone();
-    return new THREE7.Quaternion().setFromUnitVectors(
-      new THREE7.Vector3(0, 0, -1),
+    return new THREE19.Quaternion().setFromUnitVectors(
+      new THREE19.Vector3(0, 0, -1),
       input.rayDirection.clone().normalize()
     );
   }
@@ -6748,10 +7163,57 @@ var _XRInteractionSystem = class _XRInteractionSystem {
   getHoveredEntityId() {
     return this.hoveredEntityId;
   }
+  /**
+   * What this hand is pointing at, with the distance to it.
+   *
+   * The distance is what lets the pointer ray stop at the surface instead of
+   * passing through the object.
+   */
+  getHoverFor(handedness) {
+    for (const [input, hover] of this.hovers) {
+      if (input.handedness === handedness) return hover;
+    }
+    return null;
+  }
+  /** Every entity under a pointer this frame — drives hover feedback. */
+  getHoveredEntityIds() {
+    const ids = /* @__PURE__ */ new Set();
+    for (const hover of this.hovers.values()) ids.add(hover.entityId);
+    return ids;
+  }
+  /** Entities currently held, so hover feedback can skip them. */
+  getHeldEntityIds() {
+    const ids = /* @__PURE__ */ new Set();
+    for (const record of this.grabs.values()) ids.add(record.entityId);
+    return ids;
+  }
   /** True when any source is holding something. */
   isGrabbing() {
     return this.grabs.size > 0;
   }
+  /**
+   * How an entity is currently held.
+   *
+   * Exposed for scripts: a Behaviour can poll this in `onUpdate` to drive
+   * two-hand-specific behaviour — showing a bipod when both hands are on a
+   * weapon, reading the live hand separation to gate a gesture, or reacting to
+   * the scale a pull-apart produced. Returns null when nothing holds it.
+   */
+  getGrabInfo(entityId) {
+    const holders = this.holdersOf(entityId);
+    if (holders.length === 0) return null;
+    const primary = holders.find((h) => h.record.role === "primary");
+    const secondary = holders.find((h) => h.record.role === "secondary");
+    return {
+      hands: holders.length,
+      primaryHandedness: primary?.input.handedness ?? null,
+      secondaryHandedness: secondary?.input.handedness ?? null,
+      handSeparation: primary && secondary ? this.handPosition(primary.input).distanceTo(
+        this.handPosition(secondary.input)
+      ) : null,
+      attachPointIds: holders.map((h) => h.record.attachPointId)
+    };
+  }
 };
 __name(_XRInteractionSystem, "XRInteractionSystem");
 var XRInteractionSystem = _XRInteractionSystem;
@@ -6769,7 +7231,7 @@ function sampleTeleportArc(origin, direction, out = [], options) {
   for (let i = 0; i < steps; i += 1) {
     const t = i / (steps - 1) * maxTime;
     out.push(
-      new THREE7.Vector3(
+      new THREE19.Vector3(
         origin.x + velocity.x * t,
         origin.y + velocity.y * t - 0.5 * gravity * t * t,
         origin.z + velocity.z * t
@@ -6786,7 +7248,7 @@ function arcGroundCrossing(points, groundY) {
     if (previous.y >= groundY && current.y <= groundY) {
       const span = previous.y - current.y;
       const alpha = span > 1e-6 ? (previous.y - groundY) / span : 0;
-      return new THREE7.Vector3().lerpVectors(previous, current, alpha);
+      return new THREE19.Vector3().lerpVectors(previous, current, alpha);
     }
   }
   return null;
@@ -6794,11 +7256,11 @@ function arcGroundCrossing(points, groundY) {
 __name(arcGroundCrossing, "arcGroundCrossing");
 
 // core/systems/XRLocomotionSystem.ts
-var UP = new THREE7.Vector3(0, 1, 0);
+var UP = new THREE19.Vector3(0, 1, 0);
 var AXIS_DEADZONE = 0.5;
 var _XRLocomotionSystem = class _XRLocomotionSystem {
   constructor(inputSystem) {
-    this.raycaster = new THREE7.Raycaster();
+    this.raycaster = new THREE19.Raycaster();
     /** Per-source latch so one stick push yields exactly one snap turn. */
     this.turnLatched = /* @__PURE__ */ new WeakSet();
     /** Reused arc buffer — aiming runs every frame. */
@@ -6907,7 +7369,7 @@ var _XRLocomotionSystem = class _XRLocomotionSystem {
       }
       if (this.turnLatched.has(source)) continue;
       this.turnLatched.add(source);
-      transform.rotation.y -= Math.sign(x) * THREE7.MathUtils.degToRad(rig.snapTurnDegrees);
+      transform.rotation.y -= Math.sign(x) * THREE19.MathUtils.degToRad(rig.snapTurnDegrees);
     }
   }
   applySmoothMove(world, rig, transform, inputs, deltaTime) {
@@ -6917,12 +7379,12 @@ var _XRLocomotionSystem = class _XRLocomotionSystem {
       const y = input.axes[1] ?? 0;
       if (Math.abs(x) < 0.15 && Math.abs(y) < 0.15) continue;
       const camera = world.getCamera();
-      const forward = new THREE7.Vector3();
+      const forward = new THREE19.Vector3();
       camera.getWorldDirection(forward);
       forward.y = 0;
       if (forward.lengthSq() < 1e-6) continue;
       forward.normalize();
-      const right = new THREE7.Vector3().crossVectors(forward, UP).normalize();
+      const right = new THREE19.Vector3().crossVectors(forward, UP).normalize();
       const step = rig.moveSpeed * Math.max(0, deltaTime);
       transform.position.x += (forward.x * -y + right.x * x) * step;
       transform.position.z += (forward.z * -y + right.z * x) * step;
@@ -6987,7 +7449,7 @@ var _XRLocomotionSystem = class _XRLocomotionSystem {
     for (let i = 1; i < points.length; i += 1) {
       const from = points[i - 1];
       const to = points[i];
-      const delta = new THREE7.Vector3().subVectors(to, from);
+      const delta = new THREE19.Vector3().subVectors(to, from);
       const distance = delta.length();
       if (distance < 1e-6) continue;
       this.raycaster.set(from, delta.divideScalar(distance));
@@ -7195,9 +7657,9 @@ var XRSessionSystem = _XRSessionSystem;
 function buildGeometry2(area) {
   if (area.shape === "circle") {
     const radius = Math.max(5e-3, area.width / 2);
-    return new THREE7.CircleGeometry(radius, 48);
+    return new THREE19.CircleGeometry(radius, 48);
   }
-  return new THREE7.PlaneGeometry(
+  return new THREE19.PlaneGeometry(
     Math.max(0.01, area.width),
     Math.max(0.01, area.depth)
   );
@@ -7220,7 +7682,7 @@ var _VRTeleportAreaSystem = class _VRTeleportAreaSystem {
     for (const entityId of entityIds) {
       const area = world.getComponent(entityId, VRTeleportAreaComponent);
       const object = world.getComponent(entityId, Object3DRef)?.object;
-      if (!area || !(object instanceof THREE7.Mesh)) continue;
+      if (!area || !(object instanceof THREE19.Mesh)) continue;
       const signature = signatureOf(area);
       if (this.signatures.get(entityId) === signature) continue;
       this.signatures.set(entityId, signature);
@@ -7232,18 +7694,18 @@ var _VRTeleportAreaSystem = class _VRTeleportAreaSystem {
 __name(_VRTeleportAreaSystem, "VRTeleportAreaSystem");
 var VRTeleportAreaSystem = _VRTeleportAreaSystem;
 function createHandMaterial(preset, options) {
-  const color = new THREE7.Color(options.color);
+  const color = new THREE19.Color(options.color);
   switch (preset) {
     case "ghost":
-      return new THREE7.MeshBasicMaterial({
+      return new THREE19.MeshBasicMaterial({
         color,
         transparent: true,
         opacity: Math.min(1, Math.max(0.05, options.opacity * 0.45)),
         depthWrite: false,
-        side: THREE7.DoubleSide
+        side: THREE19.DoubleSide
       });
     case "neon":
-      return new THREE7.MeshStandardMaterial({
+      return new THREE19.MeshStandardMaterial({
         color,
         emissive: color,
         emissiveIntensity: Math.max(0.5, options.emissiveIntensity || 2),
@@ -7253,7 +7715,7 @@ function createHandMaterial(preset, options) {
         opacity: options.opacity
       });
     case "skeleton":
-      return new THREE7.MeshBasicMaterial({
+      return new THREE19.MeshBasicMaterial({
         color,
         wireframe: true,
         transparent: true,
@@ -7261,7 +7723,7 @@ function createHandMaterial(preset, options) {
       });
     case "custom":
     case "default":
-      return new THREE7.MeshStandardMaterial({
+      return new THREE19.MeshStandardMaterial({
         color,
         roughness: 0.85,
         metalness: 0,
@@ -7269,10 +7731,10 @@ function createHandMaterial(preset, options) {
         emissiveIntensity: Math.max(0, options.emissiveIntensity),
         transparent: options.opacity < 1,
         opacity: options.opacity,
-        side: THREE7.DoubleSide
+        side: THREE19.DoubleSide
       });
     default: {
-      return new THREE7.MeshStandardMaterial({ color });
+      return new THREE19.MeshStandardMaterial({ color });
     }
   }
 }
@@ -7285,6 +7747,9 @@ function applyHandMaterial(root, material) {
   });
 }
 __name(applyHandMaterial, "applyHandMaterial");
+
+// core/systems/XRControllerVisualSystem.ts
+var RAY_LENGTH = 5;
 var SLOTS = [
   { index: 0, side: "left" },
   { index: 1, side: "right" }
@@ -7293,7 +7758,7 @@ var _XRControllerVisualSystem = class _XRControllerVisualSystem {
   constructor(options) {
     this.controllerModelFactory = new XRControllerModelFactory();
     this.handModelFactory = new XRHandModelFactory();
-    this.group = new THREE7.Group();
+    this.group = new THREE19.Group();
     this.slots = /* @__PURE__ */ new Map();
     this.attachedTo = null;
     /** Last applied preset signature, so materials rebuild only on real change. */
@@ -7323,6 +7788,7 @@ var _XRControllerVisualSystem = class _XRControllerVisualSystem {
       visuals.controllerModel.visible = showControllers && hasController;
       visuals.handModel.visible = showHands && hasHand;
       visuals.ray.visible = this.shouldShowRay(interactor);
+      this.fitRayToHover(visuals.ray, side);
       if (showHands && this.handMaterial) {
         applyHandMaterial(visuals.handModel, this.handMaterial);
       }
@@ -7403,6 +7869,18 @@ var _XRControllerVisualSystem = class _XRControllerVisualSystem {
     if (!this.interactionSystem) return true;
     return this.interactionSystem.getHoveredEntityId() !== null || this.interactionSystem.isGrabbing();
   }
+  /**
+   * Stop the ray at whatever it is pointing at.
+   *
+   * A fixed-length ray drawn with depth testing off punches straight through the
+   * object, so the user cannot tell where the pointer actually lands. Scaling it
+   * to the hit distance turns it into a pointer that meets the surface.
+   */
+  fitRayToHover(ray, side) {
+    const hover = this.interactionSystem?.getHoverFor(side) ?? null;
+    const length = hover && Number.isFinite(hover.distance) && hover.distance > 0 ? Math.min(hover.distance, RAY_LENGTH) : RAY_LENGTH;
+    ray.scale.z = length / RAY_LENGTH;
+  }
   /** Lazily build per-slot visuals; the device reports profiles late. */
   ensureSlots(world) {
     const renderer = world.getRenderer();
@@ -7442,17 +7920,17 @@ var _XRControllerVisualSystem = class _XRControllerVisualSystem {
     this.attachedTo = target;
   }
   createRay() {
-    const geometry = new THREE7.BufferGeometry().setFromPoints([
-      new THREE7.Vector3(0, 0, 0),
-      new THREE7.Vector3(0, 0, -5)
+    const geometry = new THREE19.BufferGeometry().setFromPoints([
+      new THREE19.Vector3(0, 0, 0),
+      new THREE19.Vector3(0, 0, -RAY_LENGTH)
     ]);
-    const material = new THREE7.LineBasicMaterial({
+    const material = new THREE19.LineBasicMaterial({
       color: "#4da3ff",
       transparent: true,
       opacity: 0.6,
       depthTest: false
     });
-    const line = new THREE7.Line(geometry, material);
+    const line = new THREE19.Line(geometry, material);
     line.name = "XRPointerRay";
     line.renderOrder = 999;
     line.visible = false;
@@ -7481,23 +7959,23 @@ var _XRControllerVisualSystem = class _XRControllerVisualSystem {
 __name(_XRControllerVisualSystem, "XRControllerVisualSystem");
 var XRControllerVisualSystem = _XRControllerVisualSystem;
 var MARKER_RADIUS = 0.28;
-var ACCENT = new THREE7.Color("#4da3ff");
-var BLOCKED = new THREE7.Color("#ff5a5a");
+var ACCENT = new THREE19.Color("#4da3ff");
+var BLOCKED = new THREE19.Color("#ff5a5a");
 var _XRTeleportVisualSystem = class _XRTeleportVisualSystem {
   constructor(locomotionSystem) {
-    this.group = new THREE7.Group();
-    this.arcGeometry = new THREE7.BufferGeometry();
-    this.marker = new THREE7.Group();
+    this.group = new THREE19.Group();
+    this.arcGeometry = new THREE19.BufferGeometry();
+    this.marker = new THREE19.Group();
     this.attached = false;
     this.locomotionSystem = locomotionSystem;
     this.group.name = "XRTeleportVisuals";
     this.group.userData.ecsPreviewHidden = true;
-    const arcMaterial = new THREE7.LineBasicMaterial({
+    const arcMaterial = new THREE19.LineBasicMaterial({
       vertexColors: true,
       transparent: true,
       depthTest: false
     });
-    this.arc = new THREE7.Line(this.arcGeometry, arcMaterial);
+    this.arc = new THREE19.Line(this.arcGeometry, arcMaterial);
     this.arc.frustumCulled = false;
     this.arc.renderOrder = 998;
     this.group.add(this.arc);
@@ -7545,39 +8023,39 @@ var _XRTeleportVisualSystem = class _XRTeleportVisualSystem {
     }
     this.arcGeometry.setAttribute(
       "position",
-      new THREE7.BufferAttribute(positions, 3)
+      new THREE19.BufferAttribute(positions, 3)
     );
-    this.arcGeometry.setAttribute("color", new THREE7.BufferAttribute(colors, 3));
+    this.arcGeometry.setAttribute("color", new THREE19.BufferAttribute(colors, 3));
     this.arcGeometry.computeBoundingSphere();
   }
   createRing() {
-    const geometry = new THREE7.RingGeometry(
+    const geometry = new THREE19.RingGeometry(
       MARKER_RADIUS * 0.72,
       MARKER_RADIUS,
       48
     );
     geometry.rotateX(-Math.PI / 2);
-    return new THREE7.Mesh(
+    return new THREE19.Mesh(
       geometry,
-      new THREE7.MeshBasicMaterial({
+      new THREE19.MeshBasicMaterial({
         color: ACCENT,
         transparent: true,
         opacity: 0.9,
-        side: THREE7.DoubleSide,
+        side: THREE19.DoubleSide,
         depthTest: false
       })
     );
   }
   createDot() {
-    const geometry = new THREE7.CircleGeometry(MARKER_RADIUS * 0.16, 24);
+    const geometry = new THREE19.CircleGeometry(MARKER_RADIUS * 0.16, 24);
     geometry.rotateX(-Math.PI / 2);
-    return new THREE7.Mesh(
+    return new THREE19.Mesh(
       geometry,
-      new THREE7.MeshBasicMaterial({
+      new THREE19.MeshBasicMaterial({
         color: ACCENT,
         transparent: true,
         opacity: 0.55,
-        side: THREE7.DoubleSide,
+        side: THREE19.DoubleSide,
         depthTest: false
       })
     );
@@ -7679,7 +8157,7 @@ function boneDirections(joints, finger) {
     const from = joints[chain[i - 1]];
     const to = joints[chain[i]];
     if (!from || !to) return null;
-    const direction = new THREE7.Vector3().subVectors(to, from);
+    const direction = new THREE19.Vector3().subVectors(to, from);
     if (direction.lengthSq() < 1e-12) return null;
     directions.push(direction.normalize());
   }
@@ -7752,8 +8230,8 @@ function computeSpread(joints, a, b) {
   const bBase = joints[METACARPAL_JOINTS[b]];
   const bTip = joints[TIP_JOINTS[b]];
   if (!aBase || !aTip || !bBase || !bTip) return null;
-  const dirA = new THREE7.Vector3().subVectors(aTip, aBase);
-  const dirB = new THREE7.Vector3().subVectors(bTip, bBase);
+  const dirA = new THREE19.Vector3().subVectors(aTip, aBase);
+  const dirB = new THREE19.Vector3().subVectors(bTip, bBase);
   if (dirA.lengthSq() < 1e-12 || dirB.lengthSq() < 1e-12) return null;
   return clamp01((1 - dirA.normalize().dot(dirB.normalize())) / 0.45);
 }
@@ -7763,18 +8241,18 @@ function computePalmPose(joints, handedness) {
   const indexBase = joints["index-finger-metacarpal"];
   const pinkyBase = joints["pinky-finger-metacarpal"];
   if (!wrist || !indexBase || !pinkyBase) return null;
-  const u = new THREE7.Vector3().subVectors(indexBase, wrist);
-  const v = new THREE7.Vector3().subVectors(pinkyBase, wrist);
-  const normal = new THREE7.Vector3().crossVectors(u, v);
+  const u = new THREE19.Vector3().subVectors(indexBase, wrist);
+  const v = new THREE19.Vector3().subVectors(pinkyBase, wrist);
+  const normal = new THREE19.Vector3().crossVectors(u, v);
   if (normal.lengthSq() < 1e-12) return null;
   normal.normalize();
   if (handedness === "left") normal.multiplyScalar(-1);
-  const right = new THREE7.Vector3().subVectors(indexBase, pinkyBase);
+  const right = new THREE19.Vector3().subVectors(indexBase, pinkyBase);
   if (right.lengthSq() < 1e-12) return null;
   right.normalize();
   if (handedness === "left") right.multiplyScalar(-1);
-  const up = new THREE7.Vector3().crossVectors(normal, right).normalize();
-  const center = new THREE7.Vector3().add(wrist).add(indexBase).add(pinkyBase).divideScalar(3);
+  const up = new THREE19.Vector3().crossVectors(normal, right).normalize();
+  const center = new THREE19.Vector3().add(wrist).add(indexBase).add(pinkyBase).divideScalar(3);
   return {
     center,
     normal,
@@ -7805,7 +8283,7 @@ function computeHandShape(joints, handedness) {
   const thumbTip = joints["thumb-tip"];
   let thumbDirection = null;
   if (thumbBase && thumbTip) {
-    const direction = new THREE7.Vector3().subVectors(thumbTip, thumbBase);
+    const direction = new THREE19.Vector3().subVectors(thumbTip, thumbBase);
     if (direction.lengthSq() > 1e-12) thumbDirection = direction.normalize();
   }
   return {
@@ -7837,12 +8315,12 @@ function scoreAgainst(actual, target, tolerance) {
 }
 __name(scoreAgainst, "scoreAgainst");
 var WORLD_DIRECTIONS = {
-  up: new THREE7.Vector3(0, 1, 0),
-  down: new THREE7.Vector3(0, -1, 0),
-  forward: new THREE7.Vector3(0, 0, -1),
-  back: new THREE7.Vector3(0, 0, 1),
-  left: new THREE7.Vector3(-1, 0, 0),
-  right: new THREE7.Vector3(1, 0, 0)
+  up: new THREE19.Vector3(0, 1, 0),
+  down: new THREE19.Vector3(0, -1, 0),
+  forward: new THREE19.Vector3(0, 0, -1),
+  back: new THREE19.Vector3(0, 0, 1),
+  left: new THREE19.Vector3(-1, 0, 0),
+  right: new THREE19.Vector3(1, 0, 0)
 };
 function axisVector(shape, axis) {
   if (axis === "thumb") return shape.thumbDirection;
@@ -7857,7 +8335,7 @@ function resolveDirection(direction, shape, context) {
   const head = context?.headPosition;
   const origin = shape.palm?.center;
   if (!head || !origin) return null;
-  const toHead = new THREE7.Vector3().subVectors(head, origin);
+  const toHead = new THREE19.Vector3().subVectors(head, origin);
   if (toHead.lengthSq() < 1e-12) return null;
   toHead.normalize();
   return direction === "toward-head" ? toHead : toHead.multiplyScalar(-1);
@@ -7907,8 +8385,8 @@ function matchHandPose(shape, definition, context) {
     if (!handAxis || !wanted) {
       consider(0, "orientation");
     } else {
-      const angle = THREE7.MathUtils.radToDeg(
-        Math.acos(THREE7.MathUtils.clamp(handAxis.dot(wanted), -1, 1))
+      const angle = THREE19.MathUtils.radToDeg(
+        Math.acos(THREE19.MathUtils.clamp(handAxis.dot(wanted), -1, 1))
       );
       const normalizedError = Math.max(0, angle - toleranceDegrees) / 90;
       consider(clamp01(1 - normalizedError / MATCH_FALLOFF), "orientation");
@@ -7986,7 +8464,7 @@ var _XRHandPoseSystem = class _XRHandPoseSystem {
     this.trackers = /* @__PURE__ */ new Map();
     this.shapes = /* @__PURE__ */ new Map();
     /** Reused so head-relative orientation checks allocate nothing per frame. */
-    this.headPosition = new THREE7.Vector3();
+    this.headPosition = new THREE19.Vector3();
     this.elapsed = 0;
     this.inputSystem = inputSystem;
   }
@@ -8107,7 +8585,153 @@ var _XRHandPoseSystem = class _XRHandPoseSystem {
 };
 __name(_XRHandPoseSystem, "XRHandPoseSystem");
 var XRHandPoseSystem = _XRHandPoseSystem;
+var XR_HOVER_SHELL_FLAG = "__xrHoverShell";
+var SHELL_INFLATE = 1.04;
+var SCALE_SMOOTH_SECONDS = 0.09;
+var _XRHoverVisualSystem = class _XRHoverVisualSystem {
+  constructor(interactionSystem) {
+    this.records = /* @__PURE__ */ new Map();
+    this.interactionSystem = interactionSystem;
+  }
+  update(world, deltaTime) {
+    if (!world.isXrPresenting()) {
+      this.clearAll(world);
+      return;
+    }
+    const hovered = this.interactionSystem.getHoveredEntityIds();
+    const held = this.interactionSystem.getHeldEntityIds();
+    for (const entityId of hovered) {
+      if (held.has(entityId)) continue;
+      const interactable = world.getComponent(entityId, XRInteractableComponent);
+      if (!interactable?.enabled) continue;
+      if (interactable.hoverBehavior === "none") continue;
+      this.begin(world, entityId, interactable);
+    }
+    for (const [entityId, record] of this.records) {
+      if (!hovered.has(entityId) || held.has(entityId)) {
+        record.active = false;
+      }
+    }
+    this.animate(world, deltaTime);
+  }
+  begin(world, entityId, interactable) {
+    const existing = this.records.get(entityId);
+    if (existing) {
+      existing.active = true;
+      return;
+    }
+    const transform = world.getComponent(entityId, TransformComponent);
+    if (!transform) return;
+    const wantsColor = interactable.hoverBehavior === "color" || interactable.hoverBehavior === "both";
+    this.records.set(entityId, {
+      shell: wantsColor ? this.addShell(world, entityId, interactable) : null,
+      baseScale: new THREE19.Vector3(
+        transform.scale.x,
+        transform.scale.y,
+        transform.scale.z
+      ),
+      progress: 0,
+      active: true
+    });
+  }
+  /** Build an inflated back-face copy of the object's meshes. */
+  addShell(world, entityId, interactable) {
+    const object = world.getComponent(entityId, Object3DRef)?.object;
+    if (!object) return null;
+    const material = new THREE19.MeshBasicMaterial({
+      color: new THREE19.Color(interactable.hoverColor),
+      // Back faces only, so the shell shows just outside the silhouette instead
+      // of covering the object.
+      side: THREE19.BackSide,
+      transparent: true,
+      opacity: 0.85,
+      depthWrite: false
+    });
+    const group = new THREE19.Group();
+    group.name = "XRHoverShell";
+    group.userData[XR_HOVER_SHELL_FLAG] = true;
+    group.renderOrder = 998;
+    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);
+      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 = () => {
+      };
+      group.add(clone2);
+    });
+    if (group.children.length === 0) {
+      material.dispose();
+      return null;
+    }
+    object.add(group);
+    return group;
+  }
+  animate(world, deltaTime) {
+    const step = 1 - Math.exp(-Math.max(0, deltaTime) / SCALE_SMOOTH_SECONDS);
+    for (const [entityId, record] of Array.from(this.records)) {
+      const interactable = world.getComponent(entityId, XRInteractableComponent);
+      const target = record.active ? 1 : 0;
+      record.progress += (target - record.progress) * step;
+      const wantsScale = interactable?.hoverBehavior === "scale" || interactable?.hoverBehavior === "both";
+      if (wantsScale) {
+        const transform = world.getComponent(entityId, TransformComponent);
+        if (transform) {
+          const factor = 1 + (interactable.hoverScale - 1) * Math.min(1, record.progress);
+          transform.scale.x = record.baseScale.x * factor;
+          transform.scale.y = record.baseScale.y * factor;
+          transform.scale.z = record.baseScale.z * factor;
+        }
+      }
+      if (!record.active && record.progress < 0.01) {
+        this.finish(world, entityId, record);
+      }
+    }
+  }
+  /** Remove the effect and restore the authored scale exactly. */
+  finish(world, entityId, record) {
+    const transform = world.getComponent(entityId, TransformComponent);
+    if (transform) {
+      transform.scale.x = record.baseScale.x;
+      transform.scale.y = record.baseScale.y;
+      transform.scale.z = record.baseScale.z;
+    }
+    this.disposeShell(record.shell);
+    this.records.delete(entityId);
+  }
+  disposeShell(shell) {
+    if (!shell) return;
+    shell.parent?.remove(shell);
+    shell.traverse((child) => {
+      if (child instanceof THREE19.Mesh) {
+        const material = child.material;
+        if (Array.isArray(material)) {
+          for (const entry of material) entry.dispose();
+        } else {
+          material?.dispose();
+        }
+      }
+    });
+  }
+  clearAll(world) {
+    for (const [entityId, record] of Array.from(this.records)) {
+      this.finish(world, entityId, record);
+    }
+  }
+  dispose() {
+    for (const record of this.records.values()) {
+      this.disposeShell(record.shell);
+    }
+    this.records.clear();
+  }
+};
+__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_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, ThrowVelocityTracker, TransformSyncSystem, VELOCITY_SAMPLES, VRTeleportAreaSystem, VideoSystem, XRControllerVisualSystem, XRHandPoseSystem, XRInputSystem, XRInteractionSystem, XRLocomotionSystem, XRSessionSystem, XRTeleportVisualSystem, XR_FINGERS, 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-W5TSYV6Q.js.map
-//# sourceMappingURL=chunk-W5TSYV6Q.js.map
+export { ADDED_NODE_MARKER_COMPONENT, ARC_GRAVITY, ARC_MAX_TIME, ARC_SPEED, ARC_STEPS, AnimationSystem, AudioSystem, Behaviour, CURLED_COS, CameraSyncSystem, 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, ThrowVelocityTracker, TransformSyncSystem, VELOCITY_SAMPLES, VRTeleportAreaSystem, VideoSystem, XRControllerVisualSystem, XRHandPoseSystem, 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-KLU2M43M.js.map
+//# sourceMappingURL=chunk-KLU2M43M.js.map