@threlte/xr 1.5.5 → 1.6.0

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,16 +1,17 @@
 import { useTask, useThrelte } from '@threlte/core';
-import { hands } from './useHand.svelte.js';
+import { useHand } from './useHand.svelte.js';
 import { isPresenting } from '../internal/state.svelte.js';
-import { toCurrentReadable } from './currentReadable.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) {
@@ -24,5 +25,5 @@ export const useHandJoint = (handedness, joint) => {
             invalidate();
         }
     }, { running: () => isPresenting.current });
-    return toCurrentReadable(() => jointSpace);
+    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';

package/dist/internal/inputSources.svelte.d.ts

@@ -0,0 +1,84 @@
+import type { XRGripSpace, XRHandSpace, XRTargetRaySpace } from 'three';
+import type { XRControllerModel } from 'three/examples/jsm/webxr/XRControllerModelFactory.js';
+import type { XRHandModel } from 'three/examples/jsm/webxr/XRHandModelFactory.js';
+import type { XRControllerEvents, XRHandEvents } from '../types.js';
+export type XRHandInputSource = XRInputSource & {
+    hand: XRHand;
+};
+export type XRInputSourceStateBase = {
+    id: string;
+    inputSource: XRInputSource;
+    handedness: XRHandedness;
+    isPrimary: boolean;
+    targetRay: XRTargetRaySpace;
+};
+export type XRControllerSourceState = XRInputSourceStateBase & {
+    type: 'controller';
+    grip: XRGripSpace;
+    model: XRControllerModel;
+};
+export type XRHandSourceState = Omit<XRInputSourceStateBase, 'inputSource'> & {
+    type: 'hand';
+    inputSource: XRHandInputSource;
+    hand: XRHandSpace;
+    model: XRHandModel;
+};
+export type XRGazeSourceState = XRInputSourceStateBase & {
+    type: 'gaze';
+};
+export type XRTransientPointerSourceState = XRInputSourceStateBase & {
+    type: 'transientPointer';
+};
+export type XRScreenInputSourceState = XRInputSourceStateBase & {
+    type: 'screenInput';
+};
+export type XRInputSourceState = XRControllerSourceState | XRHandSourceState | XRGazeSourceState | XRTransientPointerSourceState | XRScreenInputSourceState;
+declare class InputSourcesState {
+    current: readonly XRInputSourceState[];
+}
+export declare const inputSources: InputSourcesState;
+export type ControllerSubscriber = {
+    type: 'controller';
+    handedness: XRHandedness;
+    callbacks: XRControllerEvents;
+};
+export type HandSubscriber = {
+    type: 'hand';
+    handedness: 'left' | 'right';
+    callbacks: XRHandEvents;
+};
+export type Subscriber = ControllerSubscriber | HandSubscriber;
+/**
+ * Registers callbacks with the module-level XR input-source dispatcher.
+ *
+ * This does not subscribe to a specific `XRInputSource`, `XRSession`, or
+ * Three.js object. Instead, the subscriber is stored in the internal
+ * `subscribers` set and receives events for whichever current input-source
+ * state matches its `type` and `handedness`.
+ *
+ * For example, a `{ type: 'controller', handedness: 'left' }` subscriber will
+ * receive forwarded events for the current left controller, even if the
+ * underlying `XRInputSource` instance disconnects and reconnects.
+ *
+ * Returns a cleanup function that removes the subscriber from the dispatcher.
+ */
+export declare const addSubscriber: (sub: Subscriber) => () => void;
+export declare const dispatchEvent: (state: XRInputSourceState, eventType: string, event: unknown) => void;
+export declare const createInputSourceEvent: (state: XRInputSourceState, type: string, extra?: Record<string, unknown>) => {
+    type: string;
+    data: XRInputSource | XRHandInputSource;
+    inputSource: XRInputSource | XRHandInputSource;
+    target: XRTargetRaySpace | XRHandSpace;
+};
+export declare const dispatchInputSourceStateEvent: (state: XRInputSourceState, eventType: string, event: unknown, options?: {
+    dispatchSpaces?: boolean;
+}) => void;
+type ResolveOptions = {
+    isPrimary?: boolean;
+};
+export declare const getInputSourceState: (inputSource: XRInputSource, options?: ResolveOptions) => XRInputSourceState | undefined;
+export declare const getControllerState: (handedness: XRHandedness, options?: ResolveOptions) => XRControllerSourceState | undefined;
+export declare const getHandState: (handedness: "left" | "right", options?: ResolveOptions) => XRHandSourceState | undefined;
+export declare const dispatchInputSourceEvent: (inputSource: XRInputSource, eventType: string, event: unknown) => void;
+export declare const dispatchXRInputSourceEvent: (event: XRInputSourceEvent) => void;
+export {};