@threlte/xr 1.5.5 → 1.6.0

package/dist/plugins/pointerControls/context.js

@@ -1,14 +1,20 @@
 import { getContext, setContext } from 'svelte';
 const handContextKeys = {
-    left: Symbol('pointer-controls-context-left'),
-    right: Symbol('pointer-controls-context-right')
+    left: {
+        controller: Symbol('pointer-controls-context-left-controller'),
+        hand: Symbol('pointer-controls-context-left-hand')
+    },
+    right: {
+        controller: Symbol('pointer-controls-context-right-controller'),
+        hand: Symbol('pointer-controls-context-right-hand')
+    }
 };
 const contextKey = Symbol('pointer-controls-context');
-export const getHandContext = (hand) => {
-    return getContext(handContextKeys[hand]);
+export const getHandContext = (hand, sourceType) => {
+    return getContext(handContextKeys[hand][sourceType]);
 };
-export const setHandContext = (hand, context) => {
-    setContext(handContextKeys[hand], context);
+export const setHandContext = (hand, sourceType, context) => {
+    setContext(handContextKeys[hand][sourceType], context);
 };
 export const getControlsContext = () => {
     return getContext(contextKey);

package/dist/plugins/pointerControls/index.d.ts

@@ -1,5 +1,6 @@
+import { type CurrentWritable } from '@threlte/core';
 import { type ComputeFunction } from './compute.js';
-import type { FilterFunction } from './types.js';
+import type { FilterFunction, IntersectionEvent } from './types.js';
 export type PointerControlsOptions = {
     enabled?: boolean;
     /**
@@ -22,6 +23,6 @@ export type PointerControlsOptions = {
     fixedStep?: number;
 };
 export declare const pointerControls: (handedness: "left" | "right", options?: PointerControlsOptions) => {
-    enabled: import("@threlte/core").CurrentWritable<boolean>;
-    hovered: Map<string, import("./types.js").IntersectionEvent>;
+    enabled: CurrentWritable<boolean>;
+    hovered: Map<string, IntersectionEvent>;
 };

package/dist/plugins/pointerControls/index.js

@@ -4,43 +4,77 @@ import { defaultComputeFunction } from './compute.js';
 import { injectPointerControlsPlugin } from './plugin.svelte.js';
 import { setupPointerControls } from './setup.svelte.js';
 import { getControlsContext, getHandContext, setControlsContext, setHandContext, setInternalContext } from './context.js';
-import { pointerState } from '../../internal/state.svelte.js';
+import { pointerIntersection, pointerState } from '../../internal/state.svelte.js';
+const aggregateStates = new Map();
 export const pointerControls = (handedness, options) => {
     if (getControlsContext() === undefined) {
         injectPointerControlsPlugin();
         setInternalContext();
-        setControlsContext({
-            interactiveObjects: [],
-            raycaster: new Raycaster(),
-            compute: options?.compute ?? defaultComputeFunction,
-            filter: options?.filter
-        });
+        setControlsContext({ interactiveObjects: [] });
     }
     const context = getControlsContext();
-    if (getHandContext(handedness) === undefined) {
-        const enabled = options?.enabled ?? true;
-        const ctx = {
-            hand: handedness,
-            enabled: currentWritable(enabled),
-            pointer: currentWritable(new Vector3()),
-            pointerOverTarget: currentWritable(false),
-            lastEvent: undefined,
-            initialClick: [0, 0, 0],
-            initialHits: [],
-            hovered: new Map()
-        };
-        setHandContext(handedness, ctx);
-        setupPointerControls(context, ctx, options?.fixedStep);
-    }
-    const handContext = getHandContext(handedness);
-    observe.pre(() => [handContext.enabled], ([enabled]) => {
-        pointerState[handedness].enabled = enabled;
+    const aggregateState = aggregateStates.get(handedness) ??
+        (() => {
+            const state = {
+                enabled: currentWritable(options?.enabled ?? true),
+                hovered: new Map()
+            };
+            aggregateStates.set(handedness, state);
+            return state;
+        })();
+    const { enabled, hovered } = aggregateState;
+    let controllerContext = getHandContext(handedness, 'controller');
+    let handContext = getHandContext(handedness, 'hand');
+    const syncSharedState = () => {
+        hovered.clear();
+        for (const [id, event] of controllerContext.hovered) {
+            hovered.set(`controller:${id}`, event);
+        }
+        for (const [id, event] of handContext.hovered) {
+            hovered.set(`hand:${id}`, event);
+        }
+        // Shared handedness-level pointer visuals are currently controller-only:
+        // <Controller /> renders the cursor/ray from these globals, while hand
+        // pointer events are dispatched independently without a matching visual.
+        pointerState[handedness].hovering = controllerContext.pointerOverTarget.current;
+        pointerIntersection[handedness] = controllerContext.currentIntersection;
+    };
+    const createContext = (sourceType) => ({
+        hand: handedness,
+        sourceType,
+        enabled,
+        pointer: currentWritable(new Vector3()),
+        pointerOverTarget: currentWritable(false),
+        lastEvent: undefined,
+        initialClick: [0, 0, 0],
+        initialHits: [],
+        hovered: new Map(),
+        currentIntersection: undefined,
+        raycaster: new Raycaster(),
+        syncSharedState,
+        compute: options?.compute ?? defaultComputeFunction,
+        filter: options?.filter
     });
-    observe.pre(() => [handContext.pointerOverTarget], ([hovering]) => {
-        pointerState[handedness].hovering = hovering;
+    const setupContexts = [];
+    if (controllerContext === undefined) {
+        controllerContext = createContext('controller');
+        setHandContext(handedness, 'controller', controllerContext);
+        setupContexts.push(controllerContext);
+    }
+    if (handContext === undefined) {
+        handContext = createContext('hand');
+        setHandContext(handedness, 'hand', handContext);
+        setupContexts.push(handContext);
+    }
+    for (const setupContext of setupContexts) {
+        setupPointerControls(context, setupContext, options?.fixedStep);
+    }
+    observe.pre(() => [enabled], ([nextEnabled]) => {
+        pointerState[handedness].enabled = nextEnabled;
     });
+    syncSharedState();
     return {
-        enabled: handContext.enabled,
-        hovered: handContext.hovered
+        enabled,
+        hovered
     };
 };

package/dist/plugins/pointerControls/setup.svelte.js

@@ -1,10 +1,9 @@
 import { Vector3 } from 'three';
-import { observe } from '@threlte/core';
+import { fromStore } from 'svelte/store';
 import { getInternalContext } from './context.js';
-import { controllers } from '../../hooks/useController.svelte.js';
-import { useHand } from '../../hooks/useHand.svelte.js';
+import { addSubscriber } from '../../internal/inputSources.svelte.js';
 import { useFixed } from '../../internal/useFixed.js';
-import { isPresenting, pointerIntersection } from '../../internal/state.svelte.js';
+import { isPresenting } from '../../internal/state.svelte.js';
 // Hover identity must match the dedup key used in `getHits`, otherwise the ID
 // changes mid-hover (e.g. the hit's face index changes as the ray sweeps a
 // plain mesh) and the object flickers between pointerout/pointerenter every
@@ -20,13 +19,18 @@ const getIntersectionId = (intersection) => {
     return target.uuid;
 };
 const EPSILON = 0.0001;
+// Starts high enough to stay clear of browser-assigned DOM pointerIds in the
+// same session. Incremented per setupPointerControls call so each hand — and
+// each reconnect — gets a distinct id.
+let nextPointerId = 1001;
 export const setupPointerControls = (context, handContext, fixedStep = 1 / 40) => {
     const handedness = handContext.hand;
-    const controller = $derived(controllers[handedness]);
-    const hand = useHand(handedness);
+    const pointerId = nextPointerId++;
+    const enabled = fromStore(handContext.enabled);
     const { dispatchers } = getInternalContext();
     let hits = [];
-    const lastPosition = new Vector3();
+    const lastRayOrigin = new Vector3();
+    const lastRayDirection = new Vector3();
     const handlePointerDown = (event) => {
         // Save initial coordinates on pointer-down
         const [hit] = hits;
@@ -69,10 +73,11 @@ export const setupPointerControls = (context, handContext, fixedStep = 1 / 40) =
         if (handContext.hovered.size === 0) {
             handContext.pointerOverTarget.set(false);
         }
+        handContext.syncSharedState();
     }
     const getHits = () => {
         const intersections = [];
-        const rawHits = context.raycaster.intersectObjects(context.interactiveObjects, true);
+        const rawHits = handContext.raycaster.intersectObjects(context.interactiveObjects, true);
         const seen = new Set();
         // Deduplicate hits by object. When recursive=true, intersectObjects searches
         // each registered object's full subtree, so a child that is itself registered
@@ -92,8 +97,9 @@ export const setupPointerControls = (context, handContext, fixedStep = 1 / 40) =
             seen.add(key);
             return true;
         });
-        const filtered = context.filter === undefined ? hits : context.filter(hits, context, handContext);
-        pointerIntersection[handedness] = filtered[0];
+        const filtered = handContext.filter === undefined ? hits : handContext.filter(hits, context, handContext);
+        handContext.currentIntersection = filtered[0];
+        handContext.syncSharedState();
         // Bubble up the events, find the event source (eventObject)
         for (const hit of filtered) {
             let eventObject = hit.object;
@@ -109,11 +115,11 @@ export const setupPointerControls = (context, handContext, fixedStep = 1 / 40) =
     };
     function pointerMissed(objects, event) {
         for (const object of objects) {
-            dispatchers.get(object)?.pointermissed?.(event);
+            dispatchers.get(object)?.onpointermissed?.(event);
         }
     }
     function processHits() {
-        context.compute(context, handContext);
+        handContext.compute(context, handContext);
         return getHits();
     }
     const handleEvent = (name, event) => {
@@ -139,6 +145,7 @@ export const setupPointerControls = (context, handContext, fixedStep = 1 / 40) =
                 ...hit,
                 intersections: hits,
                 handedness,
+                pointerId,
                 stopPropagation() {
                     stopped = true;
                     intersectionEvent.stopped = true;
@@ -152,7 +159,7 @@ export const setupPointerControls = (context, handContext, fixedStep = 1 / 40) =
                 delta: 0,
                 nativeEvent: event,
                 pointer: handContext.pointer.current,
-                ray: context.raycaster.ray
+                ray: handContext.raycaster.ray
             };
             if (isPointerMove) {
                 // Move event ...
@@ -169,6 +176,7 @@ export const setupPointerControls = (context, handContext, fixedStep = 1 / 40) =
                         events.onpointerover?.(intersectionEvent);
                         events.onpointerenter?.(intersectionEvent);
                         handContext.pointerOverTarget.set(true);
+                        handContext.syncSharedState();
                     }
                     else if (hoveredItem.stopped) {
                         // If the object was previously hovered and stopped, we shouldn't allow other items to proceed
@@ -190,47 +198,59 @@ export const setupPointerControls = (context, handContext, fixedStep = 1 / 40) =
     };
     const { start, stop } = useFixed(() => {
         hits = processHits();
-        const targetRay = controller?.targetRay;
-        if (targetRay === undefined)
-            return;
-        if (targetRay.position.distanceTo(lastPosition) > EPSILON) {
+        const ray = handContext.raycaster.ray;
+        if (ray.origin.distanceToSquared(lastRayOrigin) > EPSILON * EPSILON ||
+            1 - ray.direction.dot(lastRayDirection) > EPSILON) {
             handleEvent('onpointermove');
         }
-        lastPosition.copy(targetRay.position);
+        lastRayOrigin.copy(ray.origin);
+        lastRayDirection.copy(ray.direction);
     }, {
         fixedStep,
         autoStart: false
     });
-    observe.pre(() => [controller, handContext.enabled], ([controller, $enabled]) => {
-        if (controller === undefined || !$enabled)
-            return;
-        controller.targetRay.addEventListener('selectstart', handlePointerDown);
-        controller.targetRay.addEventListener('selectend', handlePointerUp);
-        controller.targetRay.addEventListener('select', handleClick);
-        return () => {
-            controller.targetRay.removeEventListener('selectstart', handlePointerDown);
-            controller.targetRay.removeEventListener('selectend', handlePointerUp);
-            controller.targetRay.removeEventListener('select', handleClick);
-        };
-    });
-    observe.pre(() => [hand, handContext.enabled], ([input, enabled]) => {
-        if (input === undefined || !enabled)
-            return;
-        input.hand.addEventListener('pinchstart', handlePointerDown);
-        input.hand.addEventListener('pinchend', handlePointerUp);
-        input.hand.addEventListener('pinchend', handleClick);
-        return () => {
-            input.hand.removeEventListener('pinchstart', handlePointerDown);
-            input.hand.removeEventListener('pinchend', handlePointerUp);
-            input.hand.removeEventListener('pinchend', handleClick);
-        };
-    });
-    observe.pre(() => [isPresenting.current, handContext.enabled], ([isPresenting, $enabled]) => {
-        if (isPresenting && $enabled) {
+    $effect.pre(() => {
+        if (isPresenting.current && enabled.current) {
             start();
         }
         else {
             stop();
+            hits = [];
+            handContext.currentIntersection = undefined;
+            cancelPointer([]);
+            handContext.syncSharedState();
         }
     });
+    $effect.pre(() => {
+        if (handContext.sourceType !== 'controller')
+            return;
+        if (!enabled.current)
+            return;
+        return addSubscriber({
+            type: 'controller',
+            handedness,
+            callbacks: {
+                onselectstart: handlePointerDown,
+                onselectend: handlePointerUp,
+                onselect: handleClick
+            }
+        });
+    });
+    $effect.pre(() => {
+        if (handContext.sourceType !== 'hand')
+            return;
+        if (!enabled.current)
+            return;
+        return addSubscriber({
+            type: 'hand',
+            handedness,
+            callbacks: {
+                onpinchstart: handlePointerDown,
+                onpinchend: ((event) => {
+                    handlePointerUp(event);
+                    handleClick(event);
+                })
+            }
+        });
+    });
 };

package/dist/plugins/pointerControls/types.d.ts

@@ -1,6 +1,7 @@
 import type { Intersection as ThreeIntersection, Object3D, Vector3, Ray, Raycaster, Event } from 'three';
 import type { CurrentWritable } from '@threlte/core';
 import type { ComputeFunction } from './compute.js';
+export type PointerSourceType = 'controller' | 'hand';
 export type Properties<T> = Pick<T, {
     [K in keyof T]: T[K] extends (_: any) => any ? never : K;
 }[keyof T]>;
@@ -15,6 +16,9 @@ export interface IntersectionEvent extends Intersection {
     intersections: Intersection[];
     /** Which hand dispatched this event. Each controller/hand fires enter/leave/etc. independently. */
     handedness: 'left' | 'right';
+    /** Stable identifier for this pointer source. Mirrors DOM PointerEvent.pointerId so downstream
+     * consumers that key per-pointer state by id can distinguish hands / reconnects. */
+    pointerId: number;
     /** Normalized event coordinates */
     pointer: Vector3;
     /** Delta between first click and this event */
@@ -31,12 +35,11 @@ export interface IntersectionEvent extends Intersection {
 export type FilterFunction = (items: Intersection[], state: ControlsContext, handState: HandContext) => Intersection[];
 export type ControlsContext = {
     interactiveObjects: Object3D[];
-    raycaster: Raycaster;
-    compute: ComputeFunction;
-    filter?: FilterFunction | undefined;
 };
 export type HandContext = {
     hand: 'left' | 'right';
+    /** Physical XR source this runtime tracks for the handedness. */
+    sourceType: PointerSourceType;
     enabled: CurrentWritable<boolean>;
     pointer: CurrentWritable<Vector3>;
     pointerOverTarget: CurrentWritable<boolean>;
@@ -44,6 +47,14 @@ export type HandContext = {
     initialClick: [x: number, y: number, z: number];
     initialHits: Object3D[];
     hovered: Map<string, IntersectionEvent>;
+    currentIntersection: Intersection | undefined;
+    /** Per-hand raycaster — keeps `intersectionEvent.ray` consistent across the
+     * tick even when the other hand also raycasts. */
+    raycaster: Raycaster;
+    /** Syncs aggregate handedness-level state after this source mutates hover or hit state. */
+    syncSharedState: () => void;
+    compute: ComputeFunction;
+    filter?: FilterFunction | undefined;
 };
 export interface PointerCaptureTarget {
     intersection: Intersection;

package/dist/plugins/teleportControls/compute.d.ts

@@ -1,3 +1,3 @@
 import type { Context, HandContext } from './context.js';
 export type ComputeFunction = (context: Context, handContext: HandContext) => void;
-export declare const defaultComputeFunction: (context: Context, handContext: HandContext) => void;
+export declare const defaultComputeFunction: (_context: Context, handContext: HandContext) => void;

package/dist/plugins/teleportControls/compute.js

@@ -1,14 +1,17 @@
 import { Vector3 } from 'three';
 import { controllers } from '../../hooks/useController.svelte.js';
+import { hands } from '../../hooks/useHand.svelte.js';
+const origin = new Vector3();
 const forward = new Vector3();
-export const defaultComputeFunction = (context, handContext) => {
-    const targetRay = controllers[handContext.hand]?.targetRay;
+export const defaultComputeFunction = (_context, handContext) => {
+    const targetRay = controllers[handContext.hand]?.targetRay ?? hands[handContext.hand]?.targetRay;
     if (targetRay === undefined)
         return;
-    // `<Controller>` attaches targetRay to the scene root so local === world;
-    // we can read `.position`/`.quaternion` directly without a matrixWorld
-    // roundtrip (which would force-recompose the matrix three.js writes from
-    // the XR pose and introduce a drift against the visible render).
-    forward.set(0, 0, -1).applyQuaternion(targetRay.quaternion);
-    context.raycaster.set(targetRay.position, forward);
+    // Read origin/direction from matrixWorld so the ray is in real world space,
+    // even when an ancestor (e.g. <XROrigin>) has a non-identity transform.
+    // Force an update because this runs before the frame's scene.updateMatrixWorld.
+    targetRay.updateWorldMatrix(true, false);
+    origin.setFromMatrixPosition(targetRay.matrixWorld);
+    forward.set(0, 0, -1).transformDirection(targetRay.matrixWorld);
+    handContext.raycaster.set(origin, forward);
 };

package/dist/plugins/teleportControls/context.d.ts

@@ -1,6 +1,5 @@
 import { type Mesh, Raycaster, type Intersection } from 'three';
 import type { CurrentWritable } from '@threlte/core';
-import type { TeleportControlsOptions } from './index.js';
 export type ComputeFunction = (context: Context, handContext: HandContext) => void;
 export type TeleportEvents = Record<string, (arg: unknown) => void>;
 export interface Context {
@@ -8,8 +7,6 @@ export interface Context {
     surfaces: Map<string, Mesh>;
     blockers: Map<string, Mesh>;
     dispatchers: WeakMap<Mesh, Record<string, (arg: unknown) => void>>;
-    raycaster: Raycaster;
-    compute: ComputeFunction;
     addBlocker: (mesh: Mesh) => void;
     removeBlocker: (mesh: Mesh) => void;
     addSurface: (mesh: Mesh, events: TeleportEvents) => void;
@@ -20,8 +17,11 @@ export interface HandContext {
     enabled: CurrentWritable<boolean>;
     active: CurrentWritable<boolean>;
     hovered: CurrentWritable<Intersection | undefined>;
+    /** Per-hand raycaster — keeps intersection state isolated between hands. */
+    raycaster: Raycaster;
+    compute: ComputeFunction;
 }
 export declare const getHandContext: (hand: "left" | "right") => HandContext;
 export declare const setHandContext: (hand: "left" | "right", context: HandContext) => void;
 export declare const useTeleportControls: () => Context;
-export declare const createTeleportContext: (compute: TeleportControlsOptions["compute"]) => Context;
+export declare const createTeleportContext: () => Context;

package/dist/plugins/teleportControls/context.js

@@ -1,6 +1,5 @@
 import { Raycaster } from 'three';
 import { getContext, setContext } from 'svelte';
-import { defaultComputeFunction } from './compute.js';
 const handContextKeys = {
     left: Symbol('teleport-controls-context-left-hand'),
     right: Symbol('teleport-controls-context-right-hand')
@@ -15,7 +14,7 @@ export const setHandContext = (hand, context) => {
 export const useTeleportControls = () => {
     return getContext(contextKey);
 };
-export const createTeleportContext = (compute) => {
+export const createTeleportContext = () => {
     const addSurface = (mesh, events) => {
         // check if the object is already in the list
         if (context.interactiveObjects.indexOf(mesh) > -1) {
@@ -53,8 +52,6 @@ export const createTeleportContext = (compute) => {
         surfaces: new Map(),
         blockers: new Map(),
         dispatchers: new WeakMap(),
-        raycaster: new Raycaster(),
-        compute: compute ?? defaultComputeFunction,
         addBlocker,
         removeBlocker,
         addSurface,

package/dist/plugins/teleportControls/index.js

@@ -1,22 +1,25 @@
+import { Raycaster } from 'three';
 import { currentWritable, observe } from '@threlte/core';
 import { createTeleportContext, useTeleportControls, getHandContext } from './context.js';
 import { injectTeleportControlsPlugin } from './plugin.svelte.js';
 import { setHandContext } from './context.js';
 import { setupTeleportControls } from './setup.svelte.js';
+import { defaultComputeFunction } from './compute.js';
 import { teleportState } from '../../internal/state.svelte.js';
 export const teleportControls = (handedness, options) => {
     if (useTeleportControls() === undefined) {
         injectTeleportControlsPlugin();
-        createTeleportContext(options?.compute);
+        createTeleportContext();
     }
     const context = useTeleportControls();
     if (getHandContext(handedness) === undefined) {
-        const enabled = options?.enabled ?? true;
         const ctx = {
             hand: handedness,
             active: currentWritable(false),
-            enabled: currentWritable(enabled),
-            hovered: currentWritable(undefined)
+            enabled: currentWritable(options?.enabled ?? true),
+            hovered: currentWritable(undefined),
+            raycaster: new Raycaster(),
+            compute: options?.compute ?? defaultComputeFunction
         };
         setHandContext(handedness, ctx);
         setupTeleportControls(context, ctx, options?.fixedStep);

package/dist/plugins/teleportControls/setup.svelte.js

@@ -1,18 +1,19 @@
-import { observe } from '@threlte/core';
-import { controllers } from '../../hooks/useController.svelte.js';
+import { useController } from '../../hooks/useController.svelte.js';
 import { useTeleport } from '../../hooks/useTeleport.js';
 import { useFixed } from '../../internal/useFixed.js';
 import { isPresenting, teleportIntersection } from '../../internal/state.svelte.js';
+import { fromStore } from 'svelte/store';
 export const setupTeleportControls = (context, handContext, fixedStep = 1 / 40) => {
     const handedness = handContext.hand;
-    const controller = $derived(controllers[handedness]);
+    const enabled = fromStore(handContext.enabled);
+    const controller = fromStore(useController(handedness));
     const teleport = useTeleport();
     const handleHoverEnd = () => {
         handContext.hovered.set(undefined);
         teleportIntersection[handedness] = undefined;
     };
     const { start, stop } = useFixed(() => {
-        const gamepad = controller?.inputSource.gamepad;
+        const gamepad = controller.current?.inputSource.gamepad;
         if (gamepad === undefined) {
             return;
         }
@@ -30,15 +31,15 @@ export const setupTeleportControls = (context, handContext, fixedStep = 1 / 40)
             }
             return;
         }
-        context.compute(context, handContext);
-        const [intersect] = context.raycaster.intersectObjects(context.interactiveObjects, true);
+        handContext.compute(context, handContext);
+        const [intersect] = handContext.raycaster.intersectObjects(context.interactiveObjects, true);
         if (intersect === undefined) {
             if (handContext.hovered.current !== undefined) {
                 handleHoverEnd();
             }
             return;
         }
-        if (intersect !== undefined && context.blockers.has(intersect.object.uuid)) {
+        if (context.blockers.has(intersect.object.uuid)) {
             if (handContext.hovered.current !== undefined) {
                 handleHoverEnd();
             }
@@ -50,8 +51,8 @@ export const setupTeleportControls = (context, handContext, fixedStep = 1 / 40)
         fixedStep,
         autoStart: false
     });
-    observe.pre(() => [isPresenting.current, handContext.enabled], ([isPresenting, $enabled]) => {
-        if (isPresenting && $enabled) {
+    $effect.pre(() => {
+        if (isPresenting.current && enabled.current) {
             start();
         }
         else {

package/dist/plugins/touchControls/compute.d.ts

@@ -0,0 +1,3 @@
+import type { ControlsContext, HandContext } from './types.js';
+export type ComputeFunction = (context: ControlsContext, handContext: HandContext) => void;
+export declare const defaultComputeFunction: ComputeFunction;

package/dist/plugins/touchControls/compute.js

@@ -0,0 +1,13 @@
+import { hands } from '../../hooks/useHand.svelte.js';
+export const defaultComputeFunction = (_context, handContext) => {
+    handContext.originValid = false;
+    const xrhand = hands[handContext.hand];
+    if (xrhand === undefined)
+        return;
+    const jointSpace = xrhand.hand.joints[handContext.joint];
+    if (jointSpace === undefined || jointSpace.jointRadius === undefined)
+        return;
+    jointSpace.updateWorldMatrix(true, false);
+    handContext.origin.setFromMatrixPosition(jointSpace.matrixWorld);
+    handContext.originValid = true;
+};

package/dist/plugins/touchControls/context.d.ts

@@ -0,0 +1,12 @@
+import type { Object3D } from 'three';
+import type { ControlsContext, HandContext } from './types.js';
+export declare const getHandContext: (hand: "left" | "right") => HandContext;
+export declare const setHandContext: (hand: "left" | "right", context: HandContext) => void;
+export declare const getControlsContext: () => ControlsContext;
+export declare const setControlsContext: (context: ControlsContext) => void;
+interface InternalContext {
+    dispatchers: WeakMap<Object3D, Record<string, (arg: unknown) => void>>;
+}
+export declare const getInternalContext: () => InternalContext;
+export declare const setInternalContext: () => void;
+export {};

package/dist/plugins/touchControls/context.js

@@ -0,0 +1,27 @@
+import { getContext, setContext } from 'svelte';
+const handContextKeys = {
+    left: Symbol('touch-controls-context-left'),
+    right: Symbol('touch-controls-context-right')
+};
+const contextKey = Symbol('touch-controls-context');
+export const getHandContext = (hand) => {
+    return getContext(handContextKeys[hand]);
+};
+export const setHandContext = (hand, context) => {
+    setContext(handContextKeys[hand], context);
+};
+export const getControlsContext = () => {
+    return getContext(contextKey);
+};
+export const setControlsContext = (context) => {
+    setContext(contextKey, context);
+};
+const internalContextKey = Symbol('touch-controls-internal-context');
+export const getInternalContext = () => {
+    return getContext(internalContextKey);
+};
+export const setInternalContext = () => {
+    setContext(internalContextKey, {
+        dispatchers: new WeakMap()
+    });
+};

package/dist/plugins/touchControls/hook.d.ts

@@ -0,0 +1,5 @@
+import type { Object3D } from 'three';
+export declare const useTouchControls: () => {
+    addInteractiveObject: (object: Object3D, events: Record<string, (arg: unknown) => void>) => void;
+    removeInteractiveObject: (object: Object3D) => void;
+};