@threlte/xr 1.5.4 → 1.6.0

package/dist/components/internal/PointerCursor.svelte

@@ -11,6 +11,7 @@
 
 <script lang="ts">
   import { T, useTask, useThrelte } from '@threlte/core'
+  import { untrack } from 'svelte'
   import { pointerIntersection, pointerState } from '../../internal/state.svelte.js'
   import Cursor from './Cursor.svelte'
   import type { Snippet } from 'svelte'
@@ -28,6 +29,8 @@
 
   const ref = new Group()
 
+  const SURFACE_OFFSET = 0.002
+
   useTask(
     () => {
       if (intersection === undefined) {
@@ -43,17 +46,28 @@
 
       normalMatrix.getNormalMatrix(object.matrixWorld)
       worldNormal.copy(face.normal).applyMatrix3(normalMatrix).normalize()
-      ref.lookAt(vec3.addVectors(point, worldNormal))
+
+      // Float the reticle just above the surface so it doesn't z-fight
+      // with the coplanar face underneath.
+      ref.position.addScaledVector(worldNormal, SURFACE_OFFSET)
+
+      ref.lookAt(vec3.addVectors(ref.position, worldNormal))
     },
     {
       running: () => hovering && intersection !== undefined
     }
   )
 
+  // Snap to the hit point on hover entry so the reticle doesn't visibly
+  // fly in from its previous location. `intersection` is read untracked
+  // so this only reruns on hover transitions, not every frame.
   $effect.pre(() => {
-    if (hovering && intersection) {
-      ref.position.copy(intersection.point)
-    }
+    if (!hovering) return
+    untrack(() => {
+      if (intersection) {
+        ref.position.copy(intersection.point)
+      }
+    })
   })
 </script>
 

package/dist/components/internal/TeleportCursor.svelte

@@ -40,7 +40,10 @@
       if (face) {
         normalMatrix.getNormalMatrix(object.matrixWorld)
         worldNormal.copy(face.normal).applyMatrix3(normalMatrix).normalize()
-        ref.lookAt(vec3.addVectors(point, worldNormal))
+        // lookAt from the lerped position (matches PointerCursor) — using the
+        // raw hit point here causes orientation to wobble while position is
+        // still easing toward the target.
+        ref.lookAt(vec3.addVectors(ref.position, worldNormal))
       }
     },
     {

package/dist/components/internal/TeleportRay.svelte

@@ -33,6 +33,7 @@
   const positions = new Float32Array(rayDivisions * 3)
   const lineGeometry = new LineGeometry()
   const intersection = $derived(teleportIntersection[handedness])
+  let firstRender = true
 
   const setCurvePoints = (alpha = 0.3) => {
     if (intersection === undefined) return
@@ -51,9 +52,16 @@
     // Create an arc
     rayMidpoint.y += arc
 
-    curve.v0.lerp(rayStart, alpha)
-    curve.v1.lerp(rayMidpoint, alpha)
-    curve.v2.lerp(rayEnd, alpha)
+    if (firstRender) {
+      curve.v0.copy(rayStart)
+      curve.v1.copy(rayMidpoint)
+      curve.v2.copy(rayEnd)
+      firstRender = false
+    } else {
+      curve.v0.lerp(rayStart, alpha)
+      curve.v1.lerp(rayMidpoint, alpha)
+      curve.v2.lerp(rayEnd, alpha)
+    }
 
     for (let i = 0, j = 0; i < rayDivisions; i += 1, j += 3) {
       const t = i / rayDivisions
@@ -66,6 +74,10 @@
     lineGeometry.setPositions(positions)
   }
 
+  $effect(() => {
+    if (intersection === undefined) firstRender = true
+  })
+
   useTask(
     () => {
       setCurvePoints()

package/dist/hooks/currentReadable.svelte.d.ts

@@ -2,4 +2,31 @@ import { type Readable } from 'svelte/store';
 export type CurrentReadable<T> = Readable<T> & {
     current: T;
 };
-export declare const toCurrentReadable: <T>(getter: () => T) => CurrentReadable<T>;
+/**
+ * ### `runeToCurrentReadable`
+ *
+ * Bridges a Svelte 5 `$state` or `$derived` rune into the `CurrentReadable`
+ * interface, allowing rune-backed reactive values to be consumed as read-only
+ * stores by legacy or store-aware code.
+ *
+ * Pass the getter of a `$state` or `$derived` variable:
+ *
+ * ```ts
+ * let count = $state(0)
+ * const doubled = $derived(count * 2)
+ *
+ * const store = runeToCurrentReadable(() => doubled)
+ *
+ * store.subscribe((v) => console.log(v)) // reacts to rune changes
+ * console.log(store.current)             // synchronous read, no overhead
+ * ```
+ *
+ * Use this over `runeToCurrentWritable` when the value is derived or when
+ * external writes should not be allowed — for example, renderer settings
+ * that are owned by `<Canvas>` props.
+ *
+ * The `.current` property reads the rune directly and is always in sync.
+ * `.subscribe` is powered by `toStore`, which tracks the getter reactively
+ * via `$effect`.
+ */
+export declare const runeToCurrentReadable: <T>(get: () => T) => CurrentReadable<T>;

package/dist/hooks/currentReadable.svelte.js

@@ -1,11 +1,38 @@
+import { untrack } from 'svelte';
 import { toStore } from 'svelte/store';
-export const toCurrentReadable = (getter) => {
-    const store = toStore(getter);
-    store.current = getter();
-    $effect.pre(() => {
-        return store.subscribe((value) => {
-            store.current = value;
-        });
-    });
-    return store;
+/**
+ * ### `runeToCurrentReadable`
+ *
+ * Bridges a Svelte 5 `$state` or `$derived` rune into the `CurrentReadable`
+ * interface, allowing rune-backed reactive values to be consumed as read-only
+ * stores by legacy or store-aware code.
+ *
+ * Pass the getter of a `$state` or `$derived` variable:
+ *
+ * ```ts
+ * let count = $state(0)
+ * const doubled = $derived(count * 2)
+ *
+ * const store = runeToCurrentReadable(() => doubled)
+ *
+ * store.subscribe((v) => console.log(v)) // reacts to rune changes
+ * console.log(store.current)             // synchronous read, no overhead
+ * ```
+ *
+ * Use this over `runeToCurrentWritable` when the value is derived or when
+ * external writes should not be allowed — for example, renderer settings
+ * that are owned by `<Canvas>` props.
+ *
+ * The `.current` property reads the rune directly and is always in sync.
+ * `.subscribe` is powered by `toStore`, which tracks the getter reactively
+ * via `$effect`.
+ */
+export const runeToCurrentReadable = (get) => {
+    const { subscribe } = toStore(get);
+    return {
+        subscribe,
+        get current() {
+            return untrack(get);
+        }
+    };
 };

package/dist/hooks/useController.svelte.d.ts

@@ -1,9 +1,9 @@
 import type { XRController } from '../types.js';
 import { type CurrentReadable } from './currentReadable.svelte.js';
 declare class Controllers {
-    left: XRController | undefined;
-    right: XRController | undefined;
-    none: XRController | undefined;
+    get left(): XRController | undefined;
+    get right(): XRController | undefined;
+    get none(): XRController | undefined;
 }
 export declare const controllers: Controllers;
 /**

package/dist/hooks/useController.svelte.js

@@ -1,8 +1,31 @@
-import { toCurrentReadable } from './currentReadable.svelte.js';
+import { getControllerState } from '../internal/inputSources.svelte.js';
+import { runeToCurrentReadable } from './currentReadable.svelte.js';
+const controllerObjects = new WeakMap();
+const toXRController = (state) => {
+    if (state === undefined)
+        return undefined;
+    let controller = controllerObjects.get(state);
+    if (controller !== undefined)
+        return controller;
+    controller = {
+        inputSource: state.inputSource,
+        targetRay: state.targetRay,
+        grip: state.grip,
+        model: state.model
+    };
+    controllerObjects.set(state, controller);
+    return controller;
+};
 class Controllers {
-    left = $state.raw();
-    right = $state.raw();
-    none = $state.raw();
+    get left() {
+        return toXRController(getControllerState('left'));
+    }
+    get right() {
+        return toXRController(getControllerState('right'));
+    }
+    get none() {
+        return toXRController(getControllerState('none'));
+    }
 }
 export const controllers = new Controllers();
 /**
@@ -11,11 +34,11 @@ export const controllers = new Controllers();
 export const useController = (handedness) => {
     switch (handedness) {
         case 'left':
-            return toCurrentReadable(() => controllers.left);
+            return runeToCurrentReadable(() => controllers.left);
         case 'right':
-            return toCurrentReadable(() => controllers.right);
+            return runeToCurrentReadable(() => controllers.right);
         case 'none':
-            return toCurrentReadable(() => controllers.none);
+            return runeToCurrentReadable(() => controllers.none);
         default:
             throw new Error('useController handedness must be left, right, or none.');
     }

package/dist/hooks/useHand.svelte.d.ts

@@ -1,8 +1,8 @@
 import type { XRHandObject } from '../types.js';
 import { type CurrentReadable } from './currentReadable.svelte.js';
 declare class Hands {
-    left: XRHandObject | undefined;
-    right: XRHandObject | undefined;
+    get left(): XRHandObject | undefined;
+    get right(): XRHandObject | undefined;
 }
 export declare const hands: Hands;
 /**

package/dist/hooks/useHand.svelte.js

@@ -1,7 +1,28 @@
-import { toCurrentReadable } from './currentReadable.svelte.js';
+import { getHandState } from '../internal/inputSources.svelte.js';
+import { runeToCurrentReadable } from './currentReadable.svelte.js';
+const handObjects = new WeakMap();
+const toXRHandObject = (state) => {
+    if (state === undefined)
+        return undefined;
+    let hand = handObjects.get(state);
+    if (hand !== undefined)
+        return hand;
+    hand = {
+        targetRay: state.targetRay,
+        hand: state.hand,
+        model: state.model,
+        inputSource: state.inputSource.hand
+    };
+    handObjects.set(state, hand);
+    return hand;
+};
 class Hands {
-    left = $state.raw();
-    right = $state.raw();
+    get left() {
+        return toXRHandObject(getHandState('left'));
+    }
+    get right() {
+        return toXRHandObject(getHandState('right'));
+    }
 }
 export const hands = new Hands();
 /**
@@ -10,9 +31,9 @@ export const hands = new Hands();
 export const useHand = (handedness) => {
     switch (handedness) {
         case 'left':
-            return toCurrentReadable(() => hands.left);
+            return runeToCurrentReadable(() => hands.left);
         case 'right':
-            return toCurrentReadable(() => hands.right);
+            return runeToCurrentReadable(() => hands.right);
         default:
             throw new Error('useHand handedness must be left or right.');
     }

package/dist/hooks/useHandJoint.svelte.js

@@ -1,15 +1,17 @@
 import { useTask, useThrelte } from '@threlte/core';
-import { hands } from './useHand.svelte.js';
-import { toCurrentReadable } from './currentReadable.svelte.js';
+import { useHand } from './useHand.svelte.js';
+import { isPresenting } from '../internal/state.svelte.js';
+import { runeToCurrentReadable } from './currentReadable.svelte.js';
+import { fromStore } from 'svelte/store';
 /**
  * Provides a reference to a requested hand joint, once available.
  */
 export const useHandJoint = (handedness, joint) => {
     const { invalidate } = useThrelte();
-    const xrhand = $derived(hands[handedness]);
+    const hand = fromStore(useHand(handedness));
     let jointSpace = $state.raw();
     useTask(() => {
-        const space = xrhand?.hand.joints[joint];
+        const space = hand.current?.hand.joints[joint];
         // The joint radius is a good indicator that the joint is ready.
         // Re-check each frame so we pick up reconnects and clear on disconnect.
         if (space?.jointRadius !== undefined) {
@@ -22,6 +24,6 @@ export const useHandJoint = (handedness, joint) => {
             jointSpace = undefined;
             invalidate();
         }
-    });
-    return toCurrentReadable(() => jointSpace);
+    }, { running: () => isPresenting.current });
+    return runeToCurrentReadable(() => jointSpace);
 };

package/dist/hooks/useHitTest.svelte.js

@@ -1,7 +1,9 @@
 import { Matrix4 } from 'three';
 import { useThrelte, useTask } from '@threlte/core';
-import { controllers } from './useController.svelte.js';
+import { useController } from './useController.svelte.js';
+import { useXROrigin } from './useXROrigin.svelte.js';
 import { isPresenting, session } from '../internal/state.svelte.js';
+import { fromStore } from 'svelte/store';
 /**
  * Use this hook to perform a hit test per frame in an AR environment.
  *
@@ -16,25 +18,62 @@ import { isPresenting, session } from '../internal/state.svelte.js';
 export const useHitTest = (hitTestCallback, options = {}) => {
     const source = options.source ?? 'viewer';
     const { xr } = useThrelte().renderer;
+    const xrOrigin = useXROrigin();
     const hitMatrix = new Matrix4();
     let hitTestSource = $state.raw();
-    const getHitTestSource = async (space) => {
-        if (space === undefined) {
-            return;
-        }
-        hitTestSource = await session.current?.requestHitTestSource?.({ space });
-    };
     if (source === 'viewer') {
         $effect.pre(() => {
-            session.current?.requestReferenceSpace('viewer').then((space) => {
-                getHitTestSource(space);
-            });
+            const currentSession = session.current;
+            if (currentSession === undefined)
+                return;
+            let cancelled = false;
+            let created;
+            currentSession
+                .requestReferenceSpace('viewer')
+                .then((space) => currentSession.requestHitTestSource?.({ space }))
+                .then((src) => {
+                if (cancelled || src === undefined) {
+                    src?.cancel();
+                    return;
+                }
+                created = src;
+                hitTestSource = src;
+            })
+                .catch(console.error);
+            return () => {
+                cancelled = true;
+                created?.cancel();
+                if (hitTestSource === created)
+                    hitTestSource = undefined;
+            };
         });
     }
     else {
-        const controller = $derived(controllers[source === 'leftInput' ? 'left' : 'right']);
+        const controller = fromStore(useController(source === 'leftInput' ? 'left' : 'right'));
         $effect.pre(() => {
-            getHitTestSource(controller?.inputSource.targetRaySpace);
+            const currentSession = session.current;
+            const space = controller.current?.inputSource.targetRaySpace;
+            if (currentSession === undefined || space === undefined)
+                return;
+            let cancelled = false;
+            let created;
+            currentSession
+                .requestHitTestSource?.({ space })
+                ?.then((src) => {
+                if (cancelled || src === undefined) {
+                    src?.cancel();
+                    return;
+                }
+                created = src;
+                hitTestSource = src;
+            })
+                .catch(console.error);
+            return () => {
+                cancelled = true;
+                created?.cancel();
+                if (hitTestSource === created)
+                    hitTestSource = undefined;
+            };
         });
     }
     useTask(() => {
@@ -48,6 +87,11 @@ export const useHitTest = (hitTestCallback, options = {}) => {
             return hitTestCallback(hitMatrix, undefined);
         }
         hitMatrix.fromArray(pose.transform.matrix);
+        const currentOrigin = xrOrigin.current;
+        if (currentOrigin !== undefined) {
+            currentOrigin.updateWorldMatrix(true, false);
+            hitMatrix.premultiply(currentOrigin.matrixWorld);
+        }
         hitTestCallback(hitMatrix, hit);
     }, { running: () => isPresenting.current && hitTestSource !== undefined });
     $effect.pre(() => {

package/dist/hooks/useTeleport.d.ts

@@ -1,17 +1,19 @@
-import { Quaternion, type Vector3, type Vector3Tuple } from 'three';
+import { Quaternion, Vector3, type Vector3Tuple } from 'three';
 /**
- * Returns a callback to teleport the player from the world origin to a position and optional orientation.
+ * Returns a callback that teleports the player to a target position and optional orientation.
  *
- * @example
- * const teleport = useTeleport()
- * const vec3 = new THREE.Vector3()
+ * When used inside `<XROrigin>`, the origin group is translated directly — the
+ * user's feet end up at the target, and their room-scale offset from the origin is preserved.
  *
- * vec3.set(5, 0, 5)
+ * When used outside `<XROrigin>`, the underlying `XRReferenceSpace` is mutated to compensate
+ * for the viewer's current position so the feet end up at the target regardless of where the
+ * user has walked in their physical space.
  *
- * teleport(vec3)
+ * @example
+ * const teleport = useTeleport()
+ * teleport([5, 0, 5])
  *
  * const quat = new THREE.Quaternion()
- *
- * teleport(vec3, quat)
+ * teleport(new THREE.Vector3(5, 0, 5), quat)
  */
 export declare const useTeleport: () => (position: Vector3 | Vector3Tuple, orientation?: Quaternion) => void;

package/dist/hooks/useTeleport.js

@@ -1,28 +1,76 @@
-import { Quaternion } from 'three';
+import { Matrix4, Quaternion, Vector3 } from 'three';
 import { useThrelte } from '@threlte/core';
-const quaternion = new Quaternion();
+import { useXROrigin } from './useXROrigin.svelte.js';
+const defaultOrientation = new Quaternion();
 const offset = { x: 0, y: 0, z: 0 };
+const targetPosition = new Vector3();
+const localOffset = new Vector3();
+const worldOffset = new Vector3();
+const originWorldPosition = new Vector3();
+const parentWorldQuaternion = new Quaternion();
+const localQuaternion = new Quaternion();
+const inverseParentQuaternion = new Quaternion();
+const localBasis = new Matrix4();
+const worldBasis = new Matrix4();
+const inverseParentMatrix = new Matrix4();
 /**
- * Returns a callback to teleport the player from the world origin to a position and optional orientation.
+ * Returns a callback that teleports the player to a target position and optional orientation.
  *
- * @example
- * const teleport = useTeleport()
- * const vec3 = new THREE.Vector3()
+ * When used inside `<XROrigin>`, the origin group is translated directly — the
+ * user's feet end up at the target, and their room-scale offset from the origin is preserved.
  *
- * vec3.set(5, 0, 5)
+ * When used outside `<XROrigin>`, the underlying `XRReferenceSpace` is mutated to compensate
+ * for the viewer's current position so the feet end up at the target regardless of where the
+ * user has walked in their physical space.
  *
- * teleport(vec3)
+ * @example
+ * const teleport = useTeleport()
+ * teleport([5, 0, 5])
  *
  * const quat = new THREE.Quaternion()
- *
- * teleport(vec3, quat)
+ * teleport(new THREE.Vector3(5, 0, 5), quat)
  */
 export const useTeleport = () => {
     const { xr } = useThrelte().renderer;
-    /**
-     * Teleports a player from the world origin to a position and optional orientation.
-     */
-    return (position, orientation = quaternion) => {
+    const xrOrigin = useXROrigin();
+    return (position, orientation = defaultOrientation) => {
+        const currentOrigin = xrOrigin.current;
+        if (currentOrigin !== undefined) {
+            if (Array.isArray(position)) {
+                targetPosition.set(position[0], position[1], position[2]);
+            }
+            else {
+                targetPosition.copy(position);
+            }
+            const parent = currentOrigin.parent;
+            const space = xr.getReferenceSpace();
+            const pose = space === null ? undefined : xr.getFrame()?.getViewerPose(space);
+            localOffset.set(0, 0, 0);
+            if (pose !== undefined && pose !== null) {
+                localOffset.set(pose.transform.position.x, 0, pose.transform.position.z);
+            }
+            if (parent === null) {
+                localQuaternion.copy(orientation);
+                worldBasis.compose(originWorldPosition.set(0, 0, 0), localQuaternion, currentOrigin.scale);
+                worldOffset.copy(localOffset).applyMatrix4(worldBasis);
+                currentOrigin.position.copy(targetPosition).sub(worldOffset);
+                currentOrigin.quaternion.copy(localQuaternion);
+            }
+            else {
+                parent.updateWorldMatrix(true, false);
+                parent.getWorldQuaternion(parentWorldQuaternion);
+                inverseParentQuaternion.copy(parentWorldQuaternion).invert();
+                localQuaternion.copy(inverseParentQuaternion).multiply(orientation);
+                localBasis.compose(originWorldPosition.set(0, 0, 0), localQuaternion, currentOrigin.scale);
+                worldBasis.copy(parent.matrixWorld).multiply(localBasis);
+                worldOffset.copy(localOffset).applyMatrix4(worldBasis);
+                originWorldPosition.copy(targetPosition).sub(worldOffset);
+                inverseParentMatrix.copy(parent.matrixWorld).invert();
+                currentOrigin.position.copy(originWorldPosition.applyMatrix4(inverseParentMatrix));
+                currentOrigin.quaternion.copy(localQuaternion);
+            }
+            return;
+        }
         const space = xr.getReferenceSpace();
         if (space === null)
             return;

package/dist/hooks/useXR.js

@@ -1,13 +1,13 @@
 import { isPresenting, isHandTracking, session, xr } from '../internal/state.svelte.js';
-import { toCurrentReadable } from './currentReadable.svelte.js';
+import { runeToCurrentReadable } from './currentReadable.svelte.js';
 /**
  * Provides access to context related to `<XR />`.
  */
 export const useXR = () => {
     return {
-        isPresenting: toCurrentReadable(() => isPresenting.current),
-        isHandTracking: toCurrentReadable(() => isHandTracking.current),
-        session: toCurrentReadable(() => session.current),
-        xr: toCurrentReadable(() => xr.current)
+        isPresenting: runeToCurrentReadable(() => isPresenting.current),
+        isHandTracking: runeToCurrentReadable(() => isHandTracking.current),
+        session: runeToCurrentReadable(() => session.current),
+        xr: runeToCurrentReadable(() => xr.current)
     };
 };

package/dist/hooks/useXROrigin.svelte.d.ts

@@ -0,0 +1,10 @@
+import type { Group } from 'three';
+interface Context {
+    current: Group | undefined;
+}
+/**
+ * Returns XR-scoped origin state for the current `<XR>` tree. `current` is the
+ * mounted `<XROrigin>` group when present, otherwise `undefined`.
+ */
+export declare const useXROrigin: () => Context;
+export {};

package/dist/hooks/useXROrigin.svelte.js

@@ -0,0 +1,11 @@
+class XROriginState {
+    current = $state.raw();
+}
+const origin = new XROriginState();
+/**
+ * Returns XR-scoped origin state for the current `<XR>` tree. `current` is the
+ * mounted `<XROrigin>` group when present, otherwise `undefined`.
+ */
+export const useXROrigin = () => {
+    return origin;
+};

package/dist/index.d.ts

@@ -5,11 +5,13 @@ export { default as Controller } from './components/Controller.svelte';
 export { default as Hand } from './components/Hand.svelte';
 export { default as Headset } from './components/Headset.svelte';
 export { default as XR } from './components/XR.svelte';
+export { default as XROrigin } from './components/XROrigin.svelte';
 export { getXRSupportState } from './lib/getXRSupportState.js';
 export { toggleXRSession } from './lib/toggleXRSession.js';
 export { handJoints } from './lib/handJoints.js';
 export { pointerControls } from './plugins/pointerControls/index.js';
 export { teleportControls } from './plugins/teleportControls/index.js';
+export { touchControls } from './plugins/touchControls/index.js';
 export { useController } from './hooks/useController.svelte.js';
 export { useHand } from './hooks/useHand.svelte.js';
 export { useHandJoint } from './hooks/useHandJoint.svelte.js';
@@ -17,4 +19,6 @@ export { useHeadset } from './hooks/useHeadset.js';
 export { useHitTest } from './hooks/useHitTest.svelte.js';
 export { useTeleport } from './hooks/useTeleport.js';
 export { useXR } from './hooks/useXR.js';
+export { useXROrigin } from './hooks/useXROrigin.svelte.js';
 export type { XRSessionEventType, XRControllerEventType, XRHandEventType, XRControllerEvent, XRController, XRHandObject, XRHandEvent } from './types.js';
+export type { HandJoints } from './lib/handJoints.js';

package/dist/index.js

@@ -6,6 +6,7 @@ export { default as Controller } from './components/Controller.svelte';
 export { default as Hand } from './components/Hand.svelte';
 export { default as Headset } from './components/Headset.svelte';
 export { default as XR } from './components/XR.svelte';
+export { default as XROrigin } from './components/XROrigin.svelte';
 // Utilities
 export { getXRSupportState } from './lib/getXRSupportState.js';
 export { toggleXRSession } from './lib/toggleXRSession.js';
@@ -13,6 +14,7 @@ export { handJoints } from './lib/handJoints.js';
 // Plugins
 export { pointerControls } from './plugins/pointerControls/index.js';
 export { teleportControls } from './plugins/teleportControls/index.js';
+export { touchControls } from './plugins/touchControls/index.js';
 // Hooks
 export { useController } from './hooks/useController.svelte.js';
 export { useHand } from './hooks/useHand.svelte.js';
@@ -21,3 +23,4 @@ export { useHeadset } from './hooks/useHeadset.js';
 export { useHitTest } from './hooks/useHitTest.svelte.js';
 export { useTeleport } from './hooks/useTeleport.js';
 export { useXR } from './hooks/useXR.js';
+export { useXROrigin } from './hooks/useXROrigin.svelte.js';