@relu-interactives/spatial-ecs 0.3.9 → 0.3.10

package/dist/{chunk-W5TSYV6Q.js → chunk-O2HSIZFC.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-NJOO7NO6.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-ELSZ5U3F.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
         )
@@ -918,7 +918,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 +969,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 +985,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 +1012,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 +1053,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 +1085,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 +1113,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;
@@ -1226,8 +1226,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
@@ -1806,7 +1806,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 +1814,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 +1828,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 +1889,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 +1956,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 +1971,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 +1987,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 +2025,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 +2186,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 +2212,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 +2237,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 +2253,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 +2336,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 +2517,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 +2542,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 +2560,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++) {
@@ -2996,6 +2996,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;
       }
@@ -4747,7 +4771,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 +4783,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 +4845,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 +4862,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 +5000,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 +5228,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 +5608,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 +5972,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 +6098,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 +6112,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 +6152,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 +6179,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 +6192,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 +6210,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 +6222,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 +6320,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 +6441,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,23 +6466,75 @@ 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;
     /** Monotonic seconds, accumulated from deltaTime for velocity sampling. */
@@ -6470,7 +6557,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);
         }
@@ -6491,9 +6577,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
+    );
+    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 +6741,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) {
@@ -6590,7 +6789,52 @@ var _XRInteractionSystem = class _XRInteractionSystem {
     }
     return nearestId;
   }
-  grab(world, input, entityId, viaDistance) {
+  /**
+   * 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, role) {
     const transform = world.getComponent(entityId, TransformComponent);
     const interactable = world.getComponent(entityId, XRInteractableComponent);
     if (!transform || !interactable) return;
@@ -6600,21 +6844,21 @@ 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
@@ -6628,11 +6872,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 +6906,110 @@ 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;
+      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,6 +7025,30 @@ 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;
@@ -6718,7 +7082,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 +7090,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()
     );
   }
@@ -6752,6 +7116,29 @@ var _XRInteractionSystem = class _XRInteractionSystem {
   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 +7156,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 +7173,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 +7181,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 +7294,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 +7304,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 +7374,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 +7582,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 +7607,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 +7619,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 +7640,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 +7648,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 +7656,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 });
     }
   }
 }
@@ -7293,7 +7680,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. */
@@ -7442,17 +7829,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, -5)
     ]);
-    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 +7868,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 +7932,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 +8066,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 +8139,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 +8150,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 +8192,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 +8224,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 +8244,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 +8294,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 +8373,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;
   }
@@ -8109,5 +8496,5 @@ __name(_XRHandPoseSystem, "XRHandPoseSystem");
 var XRHandPoseSystem = _XRHandPoseSystem;
 
 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
+//# sourceMappingURL=chunk-O2HSIZFC.js.map
+//# sourceMappingURL=chunk-O2HSIZFC.js.map