@relu-interactives/spatial-ecs 0.3.9 → 0.3.10

package/dist/systems/index.cjs

@@ -1,6 +1,6 @@
 'use strict';
 
-var THREE14 = require('three');
+var THREE26 = require('three');
 require('three/examples/jsm/utils/SkeletonUtils.js');
 var DRACOLoader_js = require('three/examples/jsm/loaders/DRACOLoader.js');
 var FBXLoader_js = require('three/examples/jsm/loaders/FBXLoader.js');
@@ -40,7 +40,7 @@ function _interopNamespace(e) {
   return Object.freeze(n);
 }
 
-var THREE14__namespace = /*#__PURE__*/_interopNamespace(THREE14);
+var THREE26__namespace = /*#__PURE__*/_interopNamespace(THREE26);
 
 var __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
@@ -101,14 +101,14 @@ var _TransformComponent = class _TransformComponent extends Component {
       z: scale.z ?? 1
     };
   }
-  toPositionVector3(target = new THREE14.Vector3()) {
+  toPositionVector3(target = new THREE26.Vector3()) {
     return target.set(this.position.x, this.position.y, this.position.z);
   }
-  toRotationEuler(target = new THREE14.Euler(), order = "XYZ") {
+  toRotationEuler(target = new THREE26.Euler(), order = "XYZ") {
     return target.set(this.rotation.x, this.rotation.y, this.rotation.z, order);
   }
-  toRotationQuaternion(target = new THREE14.Quaternion(), order = "XYZ") {
-    const euler = new THREE14.Euler(
+  toRotationQuaternion(target = new THREE26.Quaternion(), order = "XYZ") {
+    const euler = new THREE26.Euler(
       this.rotation.x,
       this.rotation.y,
       this.rotation.z,
@@ -116,7 +116,7 @@ var _TransformComponent = class _TransformComponent extends Component {
     );
     return target.setFromEuler(euler);
   }
-  toScaleVector3(target = new THREE14.Vector3()) {
+  toScaleVector3(target = new THREE26.Vector3()) {
     return target.set(this.scale.x, this.scale.y, this.scale.z);
   }
   setPosition(input) {
@@ -134,8 +134,8 @@ var _TransformComponent = class _TransformComponent extends Component {
     return this;
   }
   setRotation(input, order = "XYZ") {
-    if (input instanceof THREE14.Quaternion) {
-      const euler = new THREE14.Euler().setFromQuaternion(input, order);
+    if (input instanceof THREE26.Quaternion) {
+      const euler = new THREE26.Euler().setFromQuaternion(input, order);
       this.rotation.x = euler.x;
       this.rotation.y = euler.y;
       this.rotation.z = euler.z;
@@ -184,10 +184,10 @@ var _ObjectManagementSystem = class _ObjectManagementSystem {
   }
   getOrCreateAudioListener() {
     const existing = this.camera.userData.ecsAudioListener;
-    if (existing instanceof THREE14__namespace.AudioListener) {
+    if (existing instanceof THREE26__namespace.AudioListener) {
       return existing;
     }
-    const listener = new THREE14__namespace.AudioListener();
+    const listener = new THREE26__namespace.AudioListener();
     this.camera.add(listener);
     this.camera.userData.ecsAudioListener = listener;
     return listener;
@@ -261,7 +261,7 @@ var _ObjectManagementSystem = class _ObjectManagementSystem {
     }
     if (dispose && object3d) {
       object3d.traverse((child) => {
-        if (child instanceof THREE14__namespace.Mesh) {
+        if (child instanceof THREE26__namespace.Mesh) {
           if (!child.geometry?.userData?.[SHARED_MODEL_RESOURCE_FLAG]) {
             child.geometry?.dispose();
           }
@@ -641,14 +641,14 @@ var _AnimationComponent = class _AnimationComponent extends Component {
       return;
     }
     this.importedClips = clips.map((entry) => {
-      if (entry instanceof THREE14__namespace.AnimationClip) {
+      if (entry instanceof THREE26__namespace.AnimationClip) {
         return { clip: entry, sourceUrl: null };
       }
       if (!entry || typeof entry !== "object") {
         return null;
       }
       const candidate = entry;
-      if (!(candidate.clip instanceof THREE14__namespace.AnimationClip)) {
+      if (!(candidate.clip instanceof THREE26__namespace.AnimationClip)) {
         return null;
       }
       return {
@@ -782,7 +782,7 @@ var DEFAULT_ORTHO_TOP = 5;
 var DEFAULT_ORTHO_BOTTOM = -5;
 var DEFAULT_ZOOM = 1;
 function inferProjection(camera) {
-  if (camera instanceof THREE14__namespace.OrthographicCamera) {
+  if (camera instanceof THREE26__namespace.OrthographicCamera) {
     return "orthographic";
   }
   return "perspective";
@@ -803,7 +803,7 @@ function readCameraFar(camera) {
 }
 __name(readCameraFar, "readCameraFar");
 function inferFov(camera) {
-  if (camera instanceof THREE14__namespace.PerspectiveCamera && Number.isFinite(camera.fov)) {
+  if (camera instanceof THREE26__namespace.PerspectiveCamera && Number.isFinite(camera.fov)) {
     return camera.fov;
   }
   return DEFAULT_FOV;
@@ -826,28 +826,28 @@ function inferFar(camera) {
 }
 __name(inferFar, "inferFar");
 function inferOrthoLeft(camera) {
-  if (camera instanceof THREE14__namespace.OrthographicCamera && Number.isFinite(camera.left)) {
+  if (camera instanceof THREE26__namespace.OrthographicCamera && Number.isFinite(camera.left)) {
     return camera.left;
   }
   return DEFAULT_ORTHO_LEFT;
 }
 __name(inferOrthoLeft, "inferOrthoLeft");
 function inferOrthoRight(camera) {
-  if (camera instanceof THREE14__namespace.OrthographicCamera && Number.isFinite(camera.right)) {
+  if (camera instanceof THREE26__namespace.OrthographicCamera && Number.isFinite(camera.right)) {
     return camera.right;
   }
   return DEFAULT_ORTHO_RIGHT;
 }
 __name(inferOrthoRight, "inferOrthoRight");
 function inferOrthoTop(camera) {
-  if (camera instanceof THREE14__namespace.OrthographicCamera && Number.isFinite(camera.top)) {
+  if (camera instanceof THREE26__namespace.OrthographicCamera && Number.isFinite(camera.top)) {
     return camera.top;
   }
   return DEFAULT_ORTHO_TOP;
 }
 __name(inferOrthoTop, "inferOrthoTop");
 function inferOrthoBottom(camera) {
-  if (camera instanceof THREE14__namespace.OrthographicCamera && Number.isFinite(camera.bottom)) {
+  if (camera instanceof THREE26__namespace.OrthographicCamera && Number.isFinite(camera.bottom)) {
     return camera.bottom;
   }
   return DEFAULT_ORTHO_BOTTOM;
@@ -863,7 +863,7 @@ __name(inferZoom, "inferZoom");
 var _CameraComponent = class _CameraComponent extends Component {
   constructor(payload = {}) {
     super();
-    this.camera = payload.camera ?? new THREE14__namespace.PerspectiveCamera();
+    this.camera = payload.camera ?? new THREE26__namespace.PerspectiveCamera();
     this.type = payload.type ?? "3d";
     this.isDefault = typeof payload.isDefault === "boolean" ? payload.isDefault : false;
     this.projection = payload.projection ?? inferProjection(payload.camera);
@@ -1666,15 +1666,15 @@ function createValueState(light) {
     castShadow: light.castShadow ?? false,
     frustumCulling: light.frustumCulled
   };
-  if (light instanceof THREE14__namespace.PointLight) {
+  if (light instanceof THREE26__namespace.PointLight) {
     base.distance = light.distance;
     base.decay = light.decay;
-  } else if (light instanceof THREE14__namespace.SpotLight) {
+  } else if (light instanceof THREE26__namespace.SpotLight) {
     base.distance = light.distance;
     base.decay = light.decay;
     base.angle = light.angle;
     base.penumbra = light.penumbra;
-  } else if (light instanceof THREE14__namespace.RectAreaLight) {
+  } else if (light instanceof THREE26__namespace.RectAreaLight) {
     base.width = light.width;
     base.height = light.height;
   }
@@ -1709,13 +1709,13 @@ function toHexColor2(value, fallback) {
 }
 __name(toHexColor2, "toHexColor");
 function getMaterialType(material) {
-  if (material instanceof THREE14__namespace.MeshPhysicalMaterial) {
+  if (material instanceof THREE26__namespace.MeshPhysicalMaterial) {
     return "physical";
   }
-  if (material instanceof THREE14__namespace.MeshPhongMaterial) {
+  if (material instanceof THREE26__namespace.MeshPhongMaterial) {
     return "phong";
   }
-  if (material instanceof THREE14__namespace.MeshBasicMaterial) {
+  if (material instanceof THREE26__namespace.MeshBasicMaterial) {
     return "basic";
   }
   return "standard";
@@ -1750,8 +1750,8 @@ function createMaterialValue(material) {
     opacity: typeof materialRecord.opacity === "number" ? materialRecord.opacity : 1,
     emissive: toHexColor2(materialRecord.emissive, "#000000"),
     emissiveIntensity: typeof materialRecord.emissiveIntensity === "number" ? materialRecord.emissiveIntensity : 0,
-    side: typeof materialRecord.side === "number" ? materialRecord.side : THREE14__namespace.FrontSide,
-    blending: typeof materialRecord.blending === "number" ? materialRecord.blending : THREE14__namespace.NormalBlending,
+    side: typeof materialRecord.side === "number" ? materialRecord.side : THREE26__namespace.FrontSide,
+    blending: typeof materialRecord.blending === "number" ? materialRecord.blending : THREE26__namespace.NormalBlending,
     depthTest: materialRecord.depthTest !== false,
     depthWrite: materialRecord.depthWrite !== false,
     wireframe: Boolean(materialRecord.wireframe),
@@ -1783,7 +1783,7 @@ function createMaterialValue(material) {
       materialRecord.lightMap
     ),
     envMap: textureImageSrc(materialRecord.envMap),
-    textureFiltering: map?.magFilter === THREE14__namespace.NearestFilter ? "sharp" : "smooth",
+    textureFiltering: map?.magFilter === THREE26__namespace.NearestFilter ? "sharp" : "smooth",
     useMipmaps: map?.generateMipmaps !== false
   };
 }
@@ -1798,8 +1798,8 @@ function defaultMaterialValue() {
     opacity: 1,
     emissive: "#000000",
     emissiveIntensity: 0,
-    side: THREE14__namespace.FrontSide,
-    blending: THREE14__namespace.NormalBlending,
+    side: THREE26__namespace.FrontSide,
+    blending: THREE26__namespace.NormalBlending,
     depthTest: true,
     depthWrite: true,
     wireframe: false,
@@ -2113,6 +2113,14 @@ var _XRInteractableComponent = class _XRInteractableComponent extends Component
       y: 0,
       z: 0
     };
+    this.grabHands = options?.grabHands ?? "handOff";
+    this.twoHandRotation = options?.twoHandRotation ?? "align";
+    this.allowTwoHandScale = options?.allowTwoHandScale ?? false;
+    this.minScale = options?.minScale ?? 0.25;
+    this.maxScale = options?.maxScale ?? 4;
+    this.attachPoints = (options?.attachPoints ?? []).map(
+      (point) => createAttachPoint(point)
+    );
     this.throwOnRelease = options?.throwOnRelease ?? true;
     this.throwStrength = options?.throwStrength ?? 1;
     this.highlightOnHover = options?.highlightOnHover ?? true;
@@ -2120,6 +2128,17 @@ var _XRInteractableComponent = class _XRInteractableComponent extends Component
 };
 __name(_XRInteractableComponent, "XRInteractableComponent");
 var XRInteractableComponent = _XRInteractableComponent;
+function createAttachPoint(partial) {
+  return {
+    id: partial.id,
+    name: partial.name ?? partial.id,
+    position: { x: 0, y: 0, z: 0, ...partial.position },
+    rotation: { x: 0, y: 0, z: 0, ...partial.rotation },
+    hand: partial.hand ?? "any",
+    role: partial.role ?? "any"
+  };
+}
+__name(createAttachPoint, "createAttachPoint");
 
 // core/components/XRRig.ts
 var _XRRigComponent = class _XRRigComponent extends Component {
@@ -2525,7 +2544,7 @@ function transitionToClip(runtime, nextClipId, crossFadeDuration) {
 }
 __name(transitionToClip, "transitionToClip");
 function applyActionState(action, component, paused, shouldLoop) {
-  const loopMode = shouldLoop ? THREE14__namespace.LoopRepeat : THREE14__namespace.LoopOnce;
+  const loopMode = shouldLoop ? THREE26__namespace.LoopRepeat : THREE26__namespace.LoopOnce;
   const repetitions = shouldLoop ? Infinity : 1;
   action.setLoop(loopMode, repetitions);
   action.clampWhenFinished = !shouldLoop;
@@ -2698,7 +2717,7 @@ var _AnimationSystem = class _AnimationSystem {
         if (runtime) {
           stopAllActions(runtime);
         }
-        const mixer = new THREE14__namespace.AnimationMixer(root);
+        const mixer = new THREE26__namespace.AnimationMixer(root);
         const entries2 = readRuntimeClipEntries(animation);
         const indexedActions = createActions(mixer, entries2);
         runtime = {
@@ -2824,11 +2843,11 @@ function normalizeOrthoBounds(component) {
 }
 __name(normalizeOrthoBounds, "normalizeOrthoBounds");
 function isPerspectiveCamera(camera) {
-  return camera instanceof THREE14__namespace.PerspectiveCamera;
+  return camera instanceof THREE26__namespace.PerspectiveCamera;
 }
 __name(isPerspectiveCamera, "isPerspectiveCamera");
 function isOrthographicCamera(camera) {
-  return camera instanceof THREE14__namespace.OrthographicCamera;
+  return camera instanceof THREE26__namespace.OrthographicCamera;
 }
 __name(isOrthographicCamera, "isOrthographicCamera");
 function readWindowAspect() {
@@ -2882,7 +2901,7 @@ var _CameraSyncSystem = class _CameraSyncSystem {
         continue;
       }
       const camera = objectRef.object;
-      if (!(camera instanceof THREE14__namespace.Camera)) {
+      if (!(camera instanceof THREE26__namespace.Camera)) {
         continue;
       }
       if (xrCamera !== null && camera === xrCamera) {
@@ -2949,7 +2968,7 @@ var MIN_DENSITY = 0;
 function createGradientTexture(effect, colors) {
   if (typeof document === "undefined") {
     const pixel = new Uint8Array([30, 30, 30, 255]);
-    const fallback = new THREE14__namespace.DataTexture(pixel, 1, 1, THREE14__namespace.RGBAFormat);
+    const fallback = new THREE26__namespace.DataTexture(pixel, 1, 1, THREE26__namespace.RGBAFormat);
     fallback.needsUpdate = true;
     return fallback;
   }
@@ -2958,7 +2977,7 @@ function createGradientTexture(effect, colors) {
   canvas.height = 512;
   const context = canvas.getContext("2d");
   if (!context) {
-    const fallback = new THREE14__namespace.CanvasTexture(canvas);
+    const fallback = new THREE26__namespace.CanvasTexture(canvas);
     fallback.needsUpdate = true;
     return fallback;
   }
@@ -2986,15 +3005,15 @@ function createGradientTexture(effect, colors) {
     context.fillRect(0, 0, 512, 512);
     context.globalCompositeOperation = "source-over";
   }
-  const texture = new THREE14__namespace.CanvasTexture(canvas);
-  texture.colorSpace = THREE14__namespace.SRGBColorSpace;
+  const texture = new THREE26__namespace.CanvasTexture(canvas);
+  texture.colorSpace = THREE26__namespace.SRGBColorSpace;
   texture.needsUpdate = true;
   return texture;
 }
 __name(createGradientTexture, "createGradientTexture");
 var _EnvironmentSyncSystem = class _EnvironmentSyncSystem {
   constructor(scene) {
-    this.textureLoader = new THREE14__namespace.TextureLoader();
+    this.textureLoader = new THREE26__namespace.TextureLoader();
     this.signature = null;
     this.activeTexture = null;
     this.pendingImageUrl = null;
@@ -3017,7 +3036,7 @@ var _EnvironmentSyncSystem = class _EnvironmentSyncSystem {
     if (skybox.type === "color") {
       this.disposeActiveTexture();
       this.pendingImageUrl = null;
-      this.scene.background = new THREE14__namespace.Color(skybox.color || "#1e1e1e");
+      this.scene.background = new THREE26__namespace.Color(skybox.color || "#1e1e1e");
       return;
     }
     if (skybox.type === "gradient") {
@@ -3051,7 +3070,7 @@ var _EnvironmentSyncSystem = class _EnvironmentSyncSystem {
           texture.dispose();
           return;
         }
-        texture.colorSpace = THREE14__namespace.SRGBColorSpace;
+        texture.colorSpace = THREE26__namespace.SRGBColorSpace;
         this.activeTexture = texture;
         this.scene.background = texture;
       },
@@ -3070,16 +3089,16 @@ var _EnvironmentSyncSystem = class _EnvironmentSyncSystem {
       this.scene.fog = null;
       return;
     }
-    const fogColor = new THREE14__namespace.Color(fog.color || "#1e1e1e");
+    const fogColor = new THREE26__namespace.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 THREE14__namespace.Fog(fogColor, near, far);
+      this.scene.fog = new THREE26__namespace.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 THREE14__namespace.FogExp2(fogColor, density);
+    this.scene.fog = new THREE26__namespace.FogExp2(fogColor, density);
   }
   update(world) {
     const entityIds = world.query(Environment);
@@ -3161,10 +3180,10 @@ var _PostprocessingSyncSystem = class _PostprocessingSyncSystem {
       );
     }
     if (values.bloom.enabled) {
-      const size = this.renderer.getSize(new THREE14__namespace.Vector2());
+      const size = this.renderer.getSize(new THREE26__namespace.Vector2());
       composer.addPass(
         new UnrealBloomPass_js.UnrealBloomPass(
-          new THREE14__namespace.Vector2(size.width, size.height),
+          new THREE26__namespace.Vector2(size.width, size.height),
           values.bloom.intensity,
           values.bloom.radius,
           values.bloom.threshold
@@ -3209,7 +3228,7 @@ var _PostprocessingSyncSystem = class _PostprocessingSyncSystem {
     if (values.dotScreen.enabled) {
       composer.addPass(
         new DotScreenPass_js.DotScreenPass(
-          new THREE14__namespace.Vector2(0, 0),
+          new THREE26__namespace.Vector2(0, 0),
           values.dotScreen.angle ?? values.dotScreen.dotScreenAngle,
           values.dotScreen.scale ?? values.dotScreen.dotScreenScale
         )
@@ -3283,7 +3302,7 @@ function computeColliderState(colliderValues, object) {
   if (!object) {
     return colliderValues;
   }
-  const scale = new THREE14__namespace.Vector3();
+  const scale = new THREE26__namespace.Vector3();
   object.getWorldScale(scale);
   return {
     ...colliderValues,
@@ -3334,8 +3353,8 @@ function createColliderDesc(RAPIER, values, triMeshData) {
     values.offsetPosition.y,
     values.offsetPosition.z
   );
-  const offsetQuaternion = new THREE14__namespace.Quaternion().setFromEuler(
-    new THREE14__namespace.Euler(
+  const offsetQuaternion = new THREE26__namespace.Quaternion().setFromEuler(
+    new THREE26__namespace.Euler(
       values.offsetRotation.x,
       values.offsetRotation.y,
       values.offsetRotation.z
@@ -3350,17 +3369,17 @@ function collectTriMeshParts(object) {
     return null;
   }
   object.updateWorldMatrix(true, true);
-  const worldScale = new THREE14__namespace.Vector3();
+  const worldScale = new THREE26__namespace.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 THREE14__namespace.Matrix4().copy(object.matrixWorld).invert();
+  const worldToObject = new THREE26__namespace.Matrix4().copy(object.matrixWorld).invert();
   const parts = [];
   object.traverse((child) => {
-    if (!(child instanceof THREE14__namespace.Mesh) || !child.geometry) {
+    if (!(child instanceof THREE26__namespace.Mesh) || !child.geometry) {
       return;
     }
     const geometry = child.geometry;
@@ -3377,7 +3396,7 @@ function collectTriMeshParts(object) {
     if (indexCount < 3) {
       return;
     }
-    const relativeMatrix = new THREE14__namespace.Matrix4().multiplyMatrices(
+    const relativeMatrix = new THREE26__namespace.Matrix4().multiplyMatrices(
       worldToObject,
       child.matrixWorld
     );
@@ -3418,7 +3437,7 @@ function createTriMeshData(collected) {
   }
   const vertices = new Float32Array(vertexTotal * 3);
   const indices = new Uint32Array(indexTotal);
-  const point = new THREE14__namespace.Vector3();
+  const point = new THREE26__namespace.Vector3();
   let vertexOffset = 0;
   let indexOffset = 0;
   for (const part of parts) {
@@ -3450,8 +3469,8 @@ function createTriMeshData(collected) {
 }
 __name(createTriMeshData, "createTriMeshData");
 function syncBodyFromTransform(body, transform) {
-  const quaternion = new THREE14__namespace.Quaternion().setFromEuler(
-    new THREE14__namespace.Euler(transform.rotation.x, transform.rotation.y, transform.rotation.z)
+  const quaternion = new THREE26__namespace.Quaternion().setFromEuler(
+    new THREE26__namespace.Euler(transform.rotation.x, transform.rotation.y, transform.rotation.z)
   );
   body.setTranslation(
     {
@@ -3478,8 +3497,8 @@ function syncTransformFromBody(transform, body) {
   transform.position.x = position.x;
   transform.position.y = position.y;
   transform.position.z = position.z;
-  const euler = new THREE14__namespace.Euler().setFromQuaternion(
-    new THREE14__namespace.Quaternion(rotation.x, rotation.y, rotation.z, rotation.w)
+  const euler = new THREE26__namespace.Euler().setFromQuaternion(
+    new THREE26__namespace.Quaternion(rotation.x, rotation.y, rotation.z, rotation.w)
   );
   transform.rotation.x = euler.x;
   transform.rotation.y = euler.y;
@@ -3591,8 +3610,8 @@ var _PhysicsSyncSystem = class _PhysicsSyncSystem {
           transform.position.y,
           transform.position.z
         );
-        const quaternion = new THREE14__namespace.Quaternion().setFromEuler(
-          new THREE14__namespace.Euler(
+        const quaternion = new THREE26__namespace.Quaternion().setFromEuler(
+          new THREE26__namespace.Euler(
             transform.rotation.x,
             transform.rotation.y,
             transform.rotation.z
@@ -4171,7 +4190,7 @@ function applyLightValues(lightComponent) {
       values.castShadow
     );
   }
-  if (light instanceof THREE14__namespace.PointLight) {
+  if (light instanceof THREE26__namespace.PointLight) {
     if (typeof values.distance === "number" && Number.isFinite(values.distance)) {
       light.distance = Math.max(MIN_LIGHT_DISTANCE, values.distance);
     }
@@ -4179,7 +4198,7 @@ function applyLightValues(lightComponent) {
       light.decay = Math.max(0, values.decay);
     }
   }
-  if (light instanceof THREE14__namespace.SpotLight) {
+  if (light instanceof THREE26__namespace.SpotLight) {
     if (typeof values.distance === "number" && Number.isFinite(values.distance)) {
       light.distance = Math.max(MIN_LIGHT_DISTANCE, values.distance);
     }
@@ -4193,7 +4212,7 @@ function applyLightValues(lightComponent) {
       light.penumbra = Math.max(0, Math.min(1, values.penumbra));
     }
   }
-  if (light instanceof THREE14__namespace.RectAreaLight) {
+  if (light instanceof THREE26__namespace.RectAreaLight) {
     if (typeof values.width === "number" && Number.isFinite(values.width)) {
       light.width = Math.max(MIN_AREA_SIZE, values.width);
     }
@@ -4254,15 +4273,15 @@ function resolveMaterialPropertyKey(key) {
 __name(resolveMaterialPropertyKey, "resolveMaterialPropertyKey");
 function createMaterialByType(type) {
   if (type === "basic") {
-    return new THREE14__namespace.MeshBasicMaterial();
+    return new THREE26__namespace.MeshBasicMaterial();
   }
   if (type === "phong") {
-    return new THREE14__namespace.MeshPhongMaterial();
+    return new THREE26__namespace.MeshPhongMaterial();
   }
   if (type === "physical") {
-    return new THREE14__namespace.MeshPhysicalMaterial();
+    return new THREE26__namespace.MeshPhysicalMaterial();
   }
-  return new THREE14__namespace.MeshStandardMaterial();
+  return new THREE26__namespace.MeshStandardMaterial();
 }
 __name(createMaterialByType, "createMaterialByType");
 function replaceMaterialAcrossObject(object, previous, next) {
@@ -4321,12 +4340,12 @@ function applyTextureFiltering(material, filtering) {
   const target = material;
   for (const slot of materialTextureSlots) {
     const texture = target[slot];
-    if (!texture || !(texture instanceof THREE14__namespace.Texture)) {
+    if (!texture || !(texture instanceof THREE26__namespace.Texture)) {
       continue;
     }
     const useMipmaps = texture.generateMipmaps !== false;
-    texture.magFilter = sharp ? THREE14__namespace.NearestFilter : THREE14__namespace.LinearFilter;
-    texture.minFilter = useMipmaps ? sharp ? THREE14__namespace.NearestMipmapNearestFilter : THREE14__namespace.LinearMipmapLinearFilter : sharp ? THREE14__namespace.NearestFilter : THREE14__namespace.LinearFilter;
+    texture.magFilter = sharp ? THREE26__namespace.NearestFilter : THREE26__namespace.LinearFilter;
+    texture.minFilter = useMipmaps ? sharp ? THREE26__namespace.NearestMipmapNearestFilter : THREE26__namespace.LinearMipmapLinearFilter : sharp ? THREE26__namespace.NearestFilter : THREE26__namespace.LinearFilter;
     texture.needsUpdate = true;
   }
   material.needsUpdate = true;
@@ -4336,12 +4355,12 @@ function setTextureMipmaps(material, enabled) {
   const target = material;
   for (const slot of materialTextureSlots) {
     const texture = target[slot];
-    if (!texture || !(texture instanceof THREE14__namespace.Texture)) {
+    if (!texture || !(texture instanceof THREE26__namespace.Texture)) {
       continue;
     }
     texture.generateMipmaps = enabled;
-    const sharp = texture.magFilter === THREE14__namespace.NearestFilter;
-    texture.minFilter = enabled ? sharp ? THREE14__namespace.NearestMipmapNearestFilter : THREE14__namespace.LinearMipmapLinearFilter : sharp ? THREE14__namespace.NearestFilter : THREE14__namespace.LinearFilter;
+    const sharp = texture.magFilter === THREE26__namespace.NearestFilter;
+    texture.minFilter = enabled ? sharp ? THREE26__namespace.NearestMipmapNearestFilter : THREE26__namespace.LinearMipmapLinearFilter : sharp ? THREE26__namespace.NearestFilter : THREE26__namespace.LinearFilter;
     texture.needsUpdate = true;
   }
   material.needsUpdate = true;
@@ -4352,7 +4371,7 @@ function assignMaterialTexture(material, rawKey, url, textureCache) {
   const key = resolveMaterialPropertyKey(rawKey);
   let texture = textureCache.get(url);
   if (!texture) {
-    texture = new THREE14__namespace.TextureLoader().load(url);
+    texture = new THREE26__namespace.TextureLoader().load(url);
     textureCache.set(url, texture);
   }
   target[key] = texture;
@@ -4390,7 +4409,7 @@ function applyMaterialState(material, value, textureCache) {
   }
   target.side = value.side;
   target.blending = value.blending;
-  target.premultipliedAlpha = value.blending === THREE14__namespace.MultiplyBlending || value.blending === THREE14__namespace.SubtractiveBlending;
+  target.premultipliedAlpha = value.blending === THREE26__namespace.MultiplyBlending || value.blending === THREE26__namespace.SubtractiveBlending;
   target.depthTest = value.depthTest;
   target.depthWrite = value.depthWrite;
   target.wireframe = value.wireframe;
@@ -4551,12 +4570,12 @@ function resolvePrimaryMesh(object) {
   if (!object) {
     return null;
   }
-  if (object instanceof THREE14__namespace.Mesh) {
+  if (object instanceof THREE26__namespace.Mesh) {
     return object;
   }
   let found = null;
   object.traverse((child) => {
-    if (!found && child instanceof THREE14__namespace.Mesh) {
+    if (!found && child instanceof THREE26__namespace.Mesh) {
       found = child;
     }
   });
@@ -4577,22 +4596,22 @@ function applyGeometry(component) {
   switch (component.kind) {
     case "cube": {
       const params = sanitized;
-      nextGeometry = new THREE14__namespace.BoxGeometry(params.width, params.height, params.depth);
+      nextGeometry = new THREE26__namespace.BoxGeometry(params.width, params.height, params.depth);
       break;
     }
     case "plane": {
       const params = sanitized;
-      nextGeometry = new THREE14__namespace.PlaneGeometry(params.width, params.height);
+      nextGeometry = new THREE26__namespace.PlaneGeometry(params.width, params.height);
       break;
     }
     case "sphere": {
       const params = sanitized;
-      nextGeometry = new THREE14__namespace.SphereGeometry(params.radius, 24, 24);
+      nextGeometry = new THREE26__namespace.SphereGeometry(params.radius, 24, 24);
       break;
     }
     case "cylinder": {
       const params = sanitized;
-      nextGeometry = new THREE14__namespace.CylinderGeometry(
+      nextGeometry = new THREE26__namespace.CylinderGeometry(
         params.radius,
         params.radius,
         params.height,
@@ -4602,7 +4621,7 @@ function applyGeometry(component) {
     }
     case "capsule": {
       const params = sanitized;
-      nextGeometry = new THREE14__namespace.CapsuleGeometry(params.radius, params.height, 4, 8);
+      nextGeometry = new THREE26__namespace.CapsuleGeometry(params.radius, params.height, 4, 8);
       break;
     }
     default:
@@ -4618,7 +4637,7 @@ function applyShadowFlags(component) {
     return;
   }
   component.object.traverse((child) => {
-    if (child instanceof THREE14__namespace.Mesh) {
+    if (child instanceof THREE26__namespace.Mesh) {
       child.castShadow = component.castShadow;
       child.receiveShadow = component.receiveShadow;
     }
@@ -4701,35 +4720,35 @@ function buildGeometry(component) {
   switch (component.meshKind) {
     case "cube": {
       const params = p;
-      return new THREE14__namespace.BoxGeometry(params.width, params.height, params.depth);
+      return new THREE26__namespace.BoxGeometry(params.width, params.height, params.depth);
     }
     case "plane": {
       const params = p;
-      return new THREE14__namespace.PlaneGeometry(params.width, params.height);
+      return new THREE26__namespace.PlaneGeometry(params.width, params.height);
     }
     case "sphere": {
       const params = p;
-      return new THREE14__namespace.SphereGeometry(params.radius, 24, 24);
+      return new THREE26__namespace.SphereGeometry(params.radius, 24, 24);
     }
     case "cylinder": {
       const params = p;
-      return new THREE14__namespace.CylinderGeometry(params.radius, params.radius, params.height, 20);
+      return new THREE26__namespace.CylinderGeometry(params.radius, params.radius, params.height, 20);
     }
     case "capsule": {
       const params = p;
-      return new THREE14__namespace.CapsuleGeometry(params.radius, params.height, 4, 8);
+      return new THREE26__namespace.CapsuleGeometry(params.radius, params.height, 4, 8);
     }
     default:
-      return new THREE14__namespace.BoxGeometry(1, 1, 1);
+      return new THREE26__namespace.BoxGeometry(1, 1, 1);
   }
 }
 __name(buildGeometry, "buildGeometry");
-var _position = new THREE14__namespace.Vector3();
-var _quaternion = new THREE14__namespace.Quaternion();
-var _euler = new THREE14__namespace.Euler();
-var _scale = new THREE14__namespace.Vector3();
-var _matrix = new THREE14__namespace.Matrix4();
-var _modelMatrix = new THREE14__namespace.Matrix4();
+var _position = new THREE26__namespace.Vector3();
+var _quaternion = new THREE26__namespace.Quaternion();
+var _euler = new THREE26__namespace.Euler();
+var _scale = new THREE26__namespace.Vector3();
+var _matrix = new THREE26__namespace.Matrix4();
+var _modelMatrix = new THREE26__namespace.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");
@@ -4882,7 +4901,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 THREE14__namespace.InstancedMesh(
+                const instancedMesh2 = new THREE26__namespace.InstancedMesh(
                   geometry2,
                   Array.isArray(sourceMaterial) ? sourceMaterial : sourceMaterial,
                   count2
@@ -4907,7 +4926,7 @@ var _InstancedMeshSystem = class _InstancedMeshSystem {
                 this.loadingSignatures.delete(targetEntityId);
                 return;
               }
-              const group = new THREE14__namespace.Group();
+              const group = new THREE26__namespace.Group();
               for (const entry of entries) {
                 group.add(entry.instancedMesh);
               }
@@ -4925,8 +4944,8 @@ var _InstancedMeshSystem = class _InstancedMeshSystem {
         }
         const count = instanceCount;
         const geometry = buildGeometry(comp);
-        const material = new THREE14__namespace.MeshStandardMaterial({ color: "#ffffff" });
-        const instancedMesh = new THREE14__namespace.InstancedMesh(geometry, material, count);
+        const material = new THREE26__namespace.MeshStandardMaterial({ color: "#ffffff" });
+        const instancedMesh = new THREE26__namespace.InstancedMesh(geometry, material, count);
         instancedMesh.castShadow = comp.castShadow;
         instancedMesh.receiveShadow = comp.receiveShadow;
         for (let i = 0; i < count; i++) {
@@ -5361,6 +5380,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) => asRecord3(point)).filter(
+          (point) => point !== null && typeof point.id === "string"
+        ).map(
+          (point) => createAttachPoint(
+            point
+          )
+        );
+      }
       if (typeof sourceInteractable.throwOnRelease === "boolean") {
         interactable.throwOnRelease = sourceInteractable.throwOnRelease;
       }
@@ -6569,7 +6612,7 @@ var _Behaviour = class _Behaviour {
     if (!this.threeRef) {
       return null;
     }
-    const position = new THREE14__namespace.Vector3();
+    const position = new THREE26__namespace.Vector3();
     this.threeRef.object.getWorldPosition(position);
     return position;
   }
@@ -6581,7 +6624,7 @@ var _Behaviour = class _Behaviour {
     if (!this.threeRef) {
       return null;
     }
-    const target = new THREE14__namespace.Vector3();
+    const target = new THREE26__namespace.Vector3();
     this.threeRef.object.getWorldDirection(target);
     return target;
   }
@@ -6643,7 +6686,7 @@ var _Behaviour = class _Behaviour {
     if (!this.threeRef) {
       return;
     }
-    const rotation = new THREE14__namespace.Quaternion();
+    const rotation = new THREE26__namespace.Quaternion();
     this.threeRef.object.getWorldQuaternion(rotation);
     rotation.slerp(targetRotation, alpha);
     this.transform.setRotation(rotation);
@@ -6660,7 +6703,7 @@ var _Behaviour = class _Behaviour {
       return;
     }
     const clone = this.threeRef.object.clone();
-    const rotation = new THREE14__namespace.Quaternion();
+    const rotation = new THREE26__namespace.Quaternion();
     clone.lookAt(targetPosition);
     clone.getWorldQuaternion(rotation);
     this.transform.setRotation(rotation);
@@ -6798,6 +6841,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.
    *
@@ -7015,8 +7069,8 @@ var _ScriptBehaviourSystem = class _ScriptBehaviourSystem {
     }, "onPointerUp");
     this.moduleLoader = moduleLoader ?? defaultModuleLoader;
     this.selectionCtx = selectionContext ?? null;
-    this.raycaster = new THREE14__namespace.Raycaster();
-    this.ndcPointer = new THREE14__namespace.Vector2();
+    this.raycaster = new THREE26__namespace.Raycaster();
+    this.ndcPointer = new THREE26__namespace.Vector2();
     if (this.selectionCtx) {
       this.selectionCtx.domElement.addEventListener("pointerdown", this.onPointerDown);
       this.selectionCtx.domElement.addEventListener("pointerup", this.onPointerUp);
@@ -7395,7 +7449,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 THREE14__namespace.Texture) value.dispose();
+        if (value instanceof THREE26__namespace.Texture) value.dispose();
       }
       mat.dispose?.();
     }
@@ -7759,7 +7813,7 @@ var _AudioSystem = class _AudioSystem {
     if (!prev || prev.volume !== opts.volume) {
       sound.setVolume(opts.volume);
     }
-    if (opts.positional && sound instanceof THREE14__namespace.PositionalAudio) {
+    if (opts.positional && sound instanceof THREE26__namespace.PositionalAudio) {
       if (!prev || prev.refDistance !== opts.refDistance) {
         sound.setRefDistance(opts.refDistance);
       }
@@ -7885,7 +7939,7 @@ var _VideoSystem = class _VideoSystem {
       component.object.scale.set(opts.width, opts.height, 1);
     }
     const material = component.material;
-    if (material instanceof THREE14__namespace.ShaderMaterial) {
+    if (material instanceof THREE26__namespace.ShaderMaterial) {
       if (!prev || prev.backgroundColor !== opts.backgroundColor) {
         material.uniforms.keyColor.value.set(opts.backgroundColor);
       }
@@ -7899,7 +7953,7 @@ var _VideoSystem = class _VideoSystem {
         material.uniforms.spill.value = opts.spill;
       }
     }
-    if (opts.positional && component.audioNode instanceof THREE14__namespace.PositionalAudio) {
+    if (opts.positional && component.audioNode instanceof THREE26__namespace.PositionalAudio) {
       const posAudio = component.audioNode;
       if (!prev || prev.refDistance !== opts.refDistance) {
         posAudio.setRefDistance(opts.refDistance);
@@ -7939,8 +7993,8 @@ function blankState(source) {
     handedness: handednessOf(source),
     kind: kindOf(source),
     connected: true,
-    rayOrigin: new THREE14__namespace.Vector3(),
-    rayDirection: new THREE14__namespace.Vector3(0, 0, -1),
+    rayOrigin: new THREE26__namespace.Vector3(),
+    rayDirection: new THREE26__namespace.Vector3(0, 0, -1),
     gripPosition: null,
     gripQuaternion: null,
     select: false,
@@ -7966,7 +8020,7 @@ function readHandJoints(frame, hand, referenceSpace, rigMatrix, existing) {
   }
   if (spaces.length === 0) return null;
   const target = existing ?? {};
-  const matrix = new THREE14__namespace.Matrix4();
+  const matrix = new THREE26__namespace.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") {
@@ -7979,7 +8033,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 THREE14__namespace.Vector3();
+        const vector = target[names[i]] ?? new THREE26__namespace.Vector3();
         vector.setFromMatrixPosition(matrix);
         target[names[i]] = vector;
       }
@@ -7997,7 +8051,7 @@ function readHandJoints(frame, hand, referenceSpace, rigMatrix, existing) {
       continue;
     }
     matrix.fromArray(pose.transform.matrix).premultiply(rigMatrix);
-    const vector = target[names[i]] ?? new THREE14__namespace.Vector3();
+    const vector = target[names[i]] ?? new THREE26__namespace.Vector3();
     vector.setFromMatrixPosition(matrix);
     target[names[i]] = vector;
     anyTracked = true;
@@ -8009,7 +8063,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 THREE14__namespace.Matrix4();
+    this.referenceToWorld = new THREE26__namespace.Matrix4();
     this.session = null;
     this.onSelectStart = /* @__PURE__ */ __name((event) => this.mark(event, "pendingSelectStart"), "onSelectStart");
     this.onSelectEnd = /* @__PURE__ */ __name((event) => this.mark(event, "pendingSelectEnd"), "onSelectEnd");
@@ -8107,19 +8161,19 @@ var _XRInputSystem = class _XRInputSystem {
       if (frame && referenceSpace && source.targetRaySpace) {
         const pose = frame.getPose(source.targetRaySpace, referenceSpace);
         if (pose) {
-          const m = new THREE14__namespace.Matrix4().fromArray(pose.transform.matrix).premultiply(rigMatrix);
+          const m = new THREE26__namespace.Matrix4().fromArray(pose.transform.matrix).premultiply(rigMatrix);
           state.rayOrigin.setFromMatrixPosition(m);
           state.rayDirection.set(0, 0, -1).applyQuaternion(
-            new THREE14__namespace.Quaternion().setFromRotationMatrix(m)
+            new THREE26__namespace.Quaternion().setFromRotationMatrix(m)
           ).normalize();
         }
       }
       if (frame && referenceSpace && source.gripSpace) {
         const gripPose = frame.getPose(source.gripSpace, referenceSpace);
         if (gripPose) {
-          const m = new THREE14__namespace.Matrix4().fromArray(gripPose.transform.matrix).premultiply(rigMatrix);
-          state.gripPosition ?? (state.gripPosition = new THREE14__namespace.Vector3());
-          state.gripQuaternion ?? (state.gripQuaternion = new THREE14__namespace.Quaternion());
+          const m = new THREE26__namespace.Matrix4().fromArray(gripPose.transform.matrix).premultiply(rigMatrix);
+          state.gripPosition ?? (state.gripPosition = new THREE26__namespace.Vector3());
+          state.gripQuaternion ?? (state.gripQuaternion = new THREE26__namespace.Quaternion());
           state.gripPosition.setFromMatrixPosition(m);
           state.gripQuaternion.setFromRotationMatrix(m);
         }
@@ -8228,15 +8282,15 @@ var _ThrowVelocityTracker = class _ThrowVelocityTracker {
     const fresh = this.samples.filter(
       (sample) => now - sample.time <= MAX_SAMPLE_AGE_SECONDS
     );
-    if (fresh.length < 2) return new THREE14__namespace.Vector3();
-    let best = new THREE14__namespace.Vector3();
+    if (fresh.length < 2) return new THREE26__namespace.Vector3();
+    let best = new THREE26__namespace.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 THREE14__namespace.Vector3().subVectors(current.position, previous.position).divideScalar(dt);
+      const velocity = new THREE26__namespace.Vector3().subVectors(current.position, previous.position).divideScalar(dt);
       const speed = velocity.length();
       if (speed > MAX_PLAUSIBLE_SPEED) continue;
       if (speed > bestSpeed) {
@@ -8253,23 +8307,75 @@ var _ThrowVelocityTracker = class _ThrowVelocityTracker {
 __name(_ThrowVelocityTracker, "ThrowVelocityTracker");
 var ThrowVelocityTracker = _ThrowVelocityTracker;
 function angularVelocityFrom(previous, current, deltaTime) {
-  if (deltaTime <= 1e-5) return new THREE14__namespace.Vector3();
+  if (deltaTime <= 1e-5) return new THREE26__namespace.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(THREE14__namespace.MathUtils.clamp(delta.w, -1, 1));
+  const angle = 2 * Math.acos(THREE26__namespace.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 THREE14__namespace.Vector3();
-  return new THREE14__namespace.Vector3(delta.x, delta.y, delta.z).divideScalar(sinHalf).multiplyScalar(angle / deltaTime);
+  if (sinHalf < 1e-6 || angle < 1e-6) return new THREE26__namespace.Vector3();
+  return new THREE26__namespace.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 THREE26__namespace.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 THREE26__namespace.Vector3().subVectors(secondary.position, primary.position).normalize();
+    const correction = new THREE26__namespace.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 THREE26__namespace.Quaternion().setFromEuler(new THREE26__namespace.Euler(r.x, r.y, r.z));
+}
+__name(quatFromEulerVec, "quatFromEulerVec");
+function writeEuler(target, q) {
+  const euler = new THREE26__namespace.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 THREE14__namespace.Raycaster();
+    this.raycaster = new THREE26__namespace.Raycaster();
     this.grabs = /* @__PURE__ */ new Map();
     this.hoveredEntityId = null;
     /** Monotonic seconds, accumulated from deltaTime for velocity sampling. */
@@ -8292,7 +8398,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);
         }
@@ -8313,9 +8418,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 THREE26__namespace.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 THREE26__namespace.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 THREE26__namespace.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) {
@@ -8364,7 +8582,7 @@ var _XRInteractionSystem = class _XRInteractionSystem {
       );
       if (!interactable2) continue;
       if (interactable2.grabReach === "distance") continue;
-      const position = new THREE14__namespace.Vector3();
+      const position = new THREE26__namespace.Vector3();
       entry.object.getWorldPosition(position);
       const distance = position.distanceTo(hand);
       if (distance <= interactable2.grabRadius && distance < nearestDistance) {
@@ -8412,7 +8630,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 THREE26__namespace.Vector3(
+      transform.position.x,
+      transform.position.y,
+      transform.position.z
+    );
+    const objectQuaternion = quatFromEulerVec(transform.rotation);
+    const scale = new THREE26__namespace.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 THREE26__namespace.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;
@@ -8422,21 +8685,21 @@ var _XRInteractionSystem = class _XRInteractionSystem {
     let offset;
     let remoteDistance = 0;
     if (remote) {
-      const position = new THREE14__namespace.Vector3(
+      const position = new THREE26__namespace.Vector3(
         transform.position.x,
         transform.position.y,
         transform.position.z
       );
       remoteDistance = position.distanceTo(input.rayOrigin);
-      offset = new THREE14__namespace.Vector3();
+      offset = new THREE26__namespace.Vector3();
     } else if (viaDistance) {
-      offset = new THREE14__namespace.Vector3(
+      offset = new THREE26__namespace.Vector3(
         interactable.grabOffsetPosition.x,
         interactable.grabOffsetPosition.y,
         interactable.grabOffsetPosition.z
       );
     } else {
-      offset = new THREE14__namespace.Vector3(
+      offset = new THREE26__namespace.Vector3(
         transform.position.x - hand.x,
         transform.position.y - hand.y,
         transform.position.z - hand.z
@@ -8450,11 +8713,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 THREE26__namespace.Vector3(
+        attachPoint.position.x,
+        attachPoint.position.y,
+        attachPoint.position.z
+      ) : null,
+      attachQuaternion: attachPoint ? quatFromEulerVec(attachPoint.rotation) : null,
+      handRotationOffset,
+      twoHand: null,
       offset,
-      rotationOffset: new THREE14__namespace.Quaternion().setFromEuler(
-        new THREE14__namespace.Euler(
+      rotationOffset: new THREE26__namespace.Quaternion().setFromEuler(
+        new THREE26__namespace.Euler(
           interactable.grabOffsetRotation.x,
           interactable.grabOffsetRotation.y,
           interactable.grabOffsetRotation.z
@@ -8465,33 +8747,110 @@ var _XRInteractionSystem = class _XRInteractionSystem {
       restoreBodyType,
       tracker,
       lastHandQuaternion: handQuaternion.clone(),
-      angularVelocity: new THREE14__namespace.Vector3()
+      angularVelocity: new THREE26__namespace.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 THREE14__namespace.Vector3().copy(input.rayDirection).multiplyScalar(held.remoteDistance).add(input.rayOrigin);
+      const target = new THREE26__namespace.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 THREE26__namespace.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 THREE14__namespace.Vector3(
+      held.remote ? new THREE26__namespace.Vector3(
         transform.position.x,
         transform.position.y,
         transform.position.z
       ) : hand,
       this.elapsed
     );
-    const handQuaternion = this.handQuaternion(input);
     held.angularVelocity = angularVelocityFrom(
       held.lastHandQuaternion,
       handQuaternion,
@@ -8507,6 +8866,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;
@@ -8540,7 +8923,7 @@ var _XRInteractionSystem = class _XRInteractionSystem {
    */
   handPosition(input) {
     if (input.gripPosition) return input.gripPosition;
-    return new THREE14__namespace.Vector3().copy(input.rayDirection).multiplyScalar(RAYLESS_HOLD_DISTANCE).add(input.rayOrigin);
+    return new THREE26__namespace.Vector3().copy(input.rayDirection).multiplyScalar(RAYLESS_HOLD_DISTANCE).add(input.rayOrigin);
   }
   /**
    * Hand orientation. Grip-less sources (gaze / transient-pointer) have none,
@@ -8548,8 +8931,8 @@ var _XRInteractionSystem = class _XRInteractionSystem {
    */
   handQuaternion(input) {
     if (input.gripQuaternion) return input.gripQuaternion.clone();
-    return new THREE14__namespace.Quaternion().setFromUnitVectors(
-      new THREE14__namespace.Vector3(0, 0, -1),
+    return new THREE26__namespace.Quaternion().setFromUnitVectors(
+      new THREE26__namespace.Vector3(0, 0, -1),
       input.rayDirection.clone().normalize()
     );
   }
@@ -8574,6 +8957,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;
@@ -8591,7 +8997,7 @@ function sampleTeleportArc(origin, direction, out = [], options) {
   for (let i = 0; i < steps; i += 1) {
     const t = i / (steps - 1) * maxTime;
     out.push(
-      new THREE14__namespace.Vector3(
+      new THREE26__namespace.Vector3(
         origin.x + velocity.x * t,
         origin.y + velocity.y * t - 0.5 * gravity * t * t,
         origin.z + velocity.z * t
@@ -8603,11 +9009,11 @@ function sampleTeleportArc(origin, direction, out = [], options) {
 __name(sampleTeleportArc, "sampleTeleportArc");
 
 // core/systems/XRLocomotionSystem.ts
-var UP = new THREE14__namespace.Vector3(0, 1, 0);
+var UP = new THREE26__namespace.Vector3(0, 1, 0);
 var AXIS_DEADZONE = 0.5;
 var _XRLocomotionSystem = class _XRLocomotionSystem {
   constructor(inputSystem) {
-    this.raycaster = new THREE14__namespace.Raycaster();
+    this.raycaster = new THREE26__namespace.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. */
@@ -8716,7 +9122,7 @@ var _XRLocomotionSystem = class _XRLocomotionSystem {
       }
       if (this.turnLatched.has(source)) continue;
       this.turnLatched.add(source);
-      transform.rotation.y -= Math.sign(x) * THREE14__namespace.MathUtils.degToRad(rig.snapTurnDegrees);
+      transform.rotation.y -= Math.sign(x) * THREE26__namespace.MathUtils.degToRad(rig.snapTurnDegrees);
     }
   }
   applySmoothMove(world, rig, transform, inputs, deltaTime) {
@@ -8726,12 +9132,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 THREE14__namespace.Vector3();
+      const forward = new THREE26__namespace.Vector3();
       camera.getWorldDirection(forward);
       forward.y = 0;
       if (forward.lengthSq() < 1e-6) continue;
       forward.normalize();
-      const right = new THREE14__namespace.Vector3().crossVectors(forward, UP).normalize();
+      const right = new THREE26__namespace.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;
@@ -8796,7 +9202,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 THREE14__namespace.Vector3().subVectors(to, from);
+      const delta = new THREE26__namespace.Vector3().subVectors(to, from);
       const distance = delta.length();
       if (distance < 1e-6) continue;
       this.raycaster.set(from, delta.divideScalar(distance));
@@ -9004,9 +9410,9 @@ var XRSessionSystem = _XRSessionSystem;
 function buildGeometry2(area) {
   if (area.shape === "circle") {
     const radius = Math.max(5e-3, area.width / 2);
-    return new THREE14__namespace.CircleGeometry(radius, 48);
+    return new THREE26__namespace.CircleGeometry(radius, 48);
   }
-  return new THREE14__namespace.PlaneGeometry(
+  return new THREE26__namespace.PlaneGeometry(
     Math.max(0.01, area.width),
     Math.max(0.01, area.depth)
   );
@@ -9029,7 +9435,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 THREE14__namespace.Mesh)) continue;
+      if (!area || !(object instanceof THREE26__namespace.Mesh)) continue;
       const signature = signatureOf(area);
       if (this.signatures.get(entityId) === signature) continue;
       this.signatures.set(entityId, signature);
@@ -9041,18 +9447,18 @@ var _VRTeleportAreaSystem = class _VRTeleportAreaSystem {
 __name(_VRTeleportAreaSystem, "VRTeleportAreaSystem");
 var VRTeleportAreaSystem = _VRTeleportAreaSystem;
 function createHandMaterial(preset, options) {
-  const color = new THREE14__namespace.Color(options.color);
+  const color = new THREE26__namespace.Color(options.color);
   switch (preset) {
     case "ghost":
-      return new THREE14__namespace.MeshBasicMaterial({
+      return new THREE26__namespace.MeshBasicMaterial({
         color,
         transparent: true,
         opacity: Math.min(1, Math.max(0.05, options.opacity * 0.45)),
         depthWrite: false,
-        side: THREE14__namespace.DoubleSide
+        side: THREE26__namespace.DoubleSide
       });
     case "neon":
-      return new THREE14__namespace.MeshStandardMaterial({
+      return new THREE26__namespace.MeshStandardMaterial({
         color,
         emissive: color,
         emissiveIntensity: Math.max(0.5, options.emissiveIntensity || 2),
@@ -9062,7 +9468,7 @@ function createHandMaterial(preset, options) {
         opacity: options.opacity
       });
     case "skeleton":
-      return new THREE14__namespace.MeshBasicMaterial({
+      return new THREE26__namespace.MeshBasicMaterial({
         color,
         wireframe: true,
         transparent: true,
@@ -9070,7 +9476,7 @@ function createHandMaterial(preset, options) {
       });
     case "custom":
     case "default":
-      return new THREE14__namespace.MeshStandardMaterial({
+      return new THREE26__namespace.MeshStandardMaterial({
         color,
         roughness: 0.85,
         metalness: 0,
@@ -9078,10 +9484,10 @@ function createHandMaterial(preset, options) {
         emissiveIntensity: Math.max(0, options.emissiveIntensity),
         transparent: options.opacity < 1,
         opacity: options.opacity,
-        side: THREE14__namespace.DoubleSide
+        side: THREE26__namespace.DoubleSide
       });
     default: {
-      return new THREE14__namespace.MeshStandardMaterial({ color });
+      return new THREE26__namespace.MeshStandardMaterial({ color });
     }
   }
 }
@@ -9102,7 +9508,7 @@ var _XRControllerVisualSystem = class _XRControllerVisualSystem {
   constructor(options) {
     this.controllerModelFactory = new XRControllerModelFactory_js.XRControllerModelFactory();
     this.handModelFactory = new XRHandModelFactory_js.XRHandModelFactory();
-    this.group = new THREE14__namespace.Group();
+    this.group = new THREE26__namespace.Group();
     this.slots = /* @__PURE__ */ new Map();
     this.attachedTo = null;
     /** Last applied preset signature, so materials rebuild only on real change. */
@@ -9251,17 +9657,17 @@ var _XRControllerVisualSystem = class _XRControllerVisualSystem {
     this.attachedTo = target;
   }
   createRay() {
-    const geometry = new THREE14__namespace.BufferGeometry().setFromPoints([
-      new THREE14__namespace.Vector3(0, 0, 0),
-      new THREE14__namespace.Vector3(0, 0, -5)
+    const geometry = new THREE26__namespace.BufferGeometry().setFromPoints([
+      new THREE26__namespace.Vector3(0, 0, 0),
+      new THREE26__namespace.Vector3(0, 0, -5)
     ]);
-    const material = new THREE14__namespace.LineBasicMaterial({
+    const material = new THREE26__namespace.LineBasicMaterial({
       color: "#4da3ff",
       transparent: true,
       opacity: 0.6,
       depthTest: false
     });
-    const line = new THREE14__namespace.Line(geometry, material);
+    const line = new THREE26__namespace.Line(geometry, material);
     line.name = "XRPointerRay";
     line.renderOrder = 999;
     line.visible = false;
@@ -9290,23 +9696,23 @@ var _XRControllerVisualSystem = class _XRControllerVisualSystem {
 __name(_XRControllerVisualSystem, "XRControllerVisualSystem");
 var XRControllerVisualSystem = _XRControllerVisualSystem;
 var MARKER_RADIUS = 0.28;
-var ACCENT = new THREE14__namespace.Color("#4da3ff");
-var BLOCKED = new THREE14__namespace.Color("#ff5a5a");
+var ACCENT = new THREE26__namespace.Color("#4da3ff");
+var BLOCKED = new THREE26__namespace.Color("#ff5a5a");
 var _XRTeleportVisualSystem = class _XRTeleportVisualSystem {
   constructor(locomotionSystem) {
-    this.group = new THREE14__namespace.Group();
-    this.arcGeometry = new THREE14__namespace.BufferGeometry();
-    this.marker = new THREE14__namespace.Group();
+    this.group = new THREE26__namespace.Group();
+    this.arcGeometry = new THREE26__namespace.BufferGeometry();
+    this.marker = new THREE26__namespace.Group();
     this.attached = false;
     this.locomotionSystem = locomotionSystem;
     this.group.name = "XRTeleportVisuals";
     this.group.userData.ecsPreviewHidden = true;
-    const arcMaterial = new THREE14__namespace.LineBasicMaterial({
+    const arcMaterial = new THREE26__namespace.LineBasicMaterial({
       vertexColors: true,
       transparent: true,
       depthTest: false
     });
-    this.arc = new THREE14__namespace.Line(this.arcGeometry, arcMaterial);
+    this.arc = new THREE26__namespace.Line(this.arcGeometry, arcMaterial);
     this.arc.frustumCulled = false;
     this.arc.renderOrder = 998;
     this.group.add(this.arc);
@@ -9354,39 +9760,39 @@ var _XRTeleportVisualSystem = class _XRTeleportVisualSystem {
     }
     this.arcGeometry.setAttribute(
       "position",
-      new THREE14__namespace.BufferAttribute(positions, 3)
+      new THREE26__namespace.BufferAttribute(positions, 3)
     );
-    this.arcGeometry.setAttribute("color", new THREE14__namespace.BufferAttribute(colors, 3));
+    this.arcGeometry.setAttribute("color", new THREE26__namespace.BufferAttribute(colors, 3));
     this.arcGeometry.computeBoundingSphere();
   }
   createRing() {
-    const geometry = new THREE14__namespace.RingGeometry(
+    const geometry = new THREE26__namespace.RingGeometry(
       MARKER_RADIUS * 0.72,
       MARKER_RADIUS,
       48
     );
     geometry.rotateX(-Math.PI / 2);
-    return new THREE14__namespace.Mesh(
+    return new THREE26__namespace.Mesh(
       geometry,
-      new THREE14__namespace.MeshBasicMaterial({
+      new THREE26__namespace.MeshBasicMaterial({
         color: ACCENT,
         transparent: true,
         opacity: 0.9,
-        side: THREE14__namespace.DoubleSide,
+        side: THREE26__namespace.DoubleSide,
         depthTest: false
       })
     );
   }
   createDot() {
-    const geometry = new THREE14__namespace.CircleGeometry(MARKER_RADIUS * 0.16, 24);
+    const geometry = new THREE26__namespace.CircleGeometry(MARKER_RADIUS * 0.16, 24);
     geometry.rotateX(-Math.PI / 2);
-    return new THREE14__namespace.Mesh(
+    return new THREE26__namespace.Mesh(
       geometry,
-      new THREE14__namespace.MeshBasicMaterial({
+      new THREE26__namespace.MeshBasicMaterial({
         color: ACCENT,
         transparent: true,
         opacity: 0.55,
-        side: THREE14__namespace.DoubleSide,
+        side: THREE26__namespace.DoubleSide,
         depthTest: false
       })
     );
@@ -9488,7 +9894,7 @@ function boneDirections(joints, finger) {
     const from = joints[chain[i - 1]];
     const to = joints[chain[i]];
     if (!from || !to) return null;
-    const direction = new THREE14__namespace.Vector3().subVectors(to, from);
+    const direction = new THREE26__namespace.Vector3().subVectors(to, from);
     if (direction.lengthSq() < 1e-12) return null;
     directions.push(direction.normalize());
   }
@@ -9561,8 +9967,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 THREE14__namespace.Vector3().subVectors(aTip, aBase);
-  const dirB = new THREE14__namespace.Vector3().subVectors(bTip, bBase);
+  const dirA = new THREE26__namespace.Vector3().subVectors(aTip, aBase);
+  const dirB = new THREE26__namespace.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);
 }
@@ -9572,18 +9978,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 THREE14__namespace.Vector3().subVectors(indexBase, wrist);
-  const v = new THREE14__namespace.Vector3().subVectors(pinkyBase, wrist);
-  const normal = new THREE14__namespace.Vector3().crossVectors(u, v);
+  const u = new THREE26__namespace.Vector3().subVectors(indexBase, wrist);
+  const v = new THREE26__namespace.Vector3().subVectors(pinkyBase, wrist);
+  const normal = new THREE26__namespace.Vector3().crossVectors(u, v);
   if (normal.lengthSq() < 1e-12) return null;
   normal.normalize();
   if (handedness === "left") normal.multiplyScalar(-1);
-  const right = new THREE14__namespace.Vector3().subVectors(indexBase, pinkyBase);
+  const right = new THREE26__namespace.Vector3().subVectors(indexBase, pinkyBase);
   if (right.lengthSq() < 1e-12) return null;
   right.normalize();
   if (handedness === "left") right.multiplyScalar(-1);
-  const up = new THREE14__namespace.Vector3().crossVectors(normal, right).normalize();
-  const center = new THREE14__namespace.Vector3().add(wrist).add(indexBase).add(pinkyBase).divideScalar(3);
+  const up = new THREE26__namespace.Vector3().crossVectors(normal, right).normalize();
+  const center = new THREE26__namespace.Vector3().add(wrist).add(indexBase).add(pinkyBase).divideScalar(3);
   return {
     center,
     normal,
@@ -9614,7 +10020,7 @@ function computeHandShape(joints, handedness) {
   const thumbTip = joints["thumb-tip"];
   let thumbDirection = null;
   if (thumbBase && thumbTip) {
-    const direction = new THREE14__namespace.Vector3().subVectors(thumbTip, thumbBase);
+    const direction = new THREE26__namespace.Vector3().subVectors(thumbTip, thumbBase);
     if (direction.lengthSq() > 1e-12) thumbDirection = direction.normalize();
   }
   return {
@@ -9646,12 +10052,12 @@ function scoreAgainst(actual, target, tolerance) {
 }
 __name(scoreAgainst, "scoreAgainst");
 var WORLD_DIRECTIONS = {
-  up: new THREE14__namespace.Vector3(0, 1, 0),
-  down: new THREE14__namespace.Vector3(0, -1, 0),
-  forward: new THREE14__namespace.Vector3(0, 0, -1),
-  back: new THREE14__namespace.Vector3(0, 0, 1),
-  left: new THREE14__namespace.Vector3(-1, 0, 0),
-  right: new THREE14__namespace.Vector3(1, 0, 0)
+  up: new THREE26__namespace.Vector3(0, 1, 0),
+  down: new THREE26__namespace.Vector3(0, -1, 0),
+  forward: new THREE26__namespace.Vector3(0, 0, -1),
+  back: new THREE26__namespace.Vector3(0, 0, 1),
+  left: new THREE26__namespace.Vector3(-1, 0, 0),
+  right: new THREE26__namespace.Vector3(1, 0, 0)
 };
 function axisVector(shape, axis) {
   if (axis === "thumb") return shape.thumbDirection;
@@ -9666,7 +10072,7 @@ function resolveDirection(direction, shape, context) {
   const head = context?.headPosition;
   const origin = shape.palm?.center;
   if (!head || !origin) return null;
-  const toHead = new THREE14__namespace.Vector3().subVectors(head, origin);
+  const toHead = new THREE26__namespace.Vector3().subVectors(head, origin);
   if (toHead.lengthSq() < 1e-12) return null;
   toHead.normalize();
   return direction === "toward-head" ? toHead : toHead.multiplyScalar(-1);
@@ -9716,8 +10122,8 @@ function matchHandPose(shape, definition, context) {
     if (!handAxis || !wanted) {
       consider(0, "orientation");
     } else {
-      const angle = THREE14__namespace.MathUtils.radToDeg(
-        Math.acos(THREE14__namespace.MathUtils.clamp(handAxis.dot(wanted), -1, 1))
+      const angle = THREE26__namespace.MathUtils.radToDeg(
+        Math.acos(THREE26__namespace.MathUtils.clamp(handAxis.dot(wanted), -1, 1))
       );
       const normalizedError = Math.max(0, angle - toleranceDegrees) / 90;
       consider(clamp01(1 - normalizedError / MATCH_FALLOFF), "orientation");
@@ -9795,7 +10201,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 THREE14__namespace.Vector3();
+    this.headPosition = new THREE26__namespace.Vector3();
     this.elapsed = 0;
     this.inputSystem = inputSystem;
   }