@viamrobotics/motion-tools 0.18.3 → 0.19.0

package/dist/__tests__/fixtures/MockCanvas.svelte

@@ -1,11 +1,10 @@
 <script>
 	import { Canvas } from '@threlte/core'
 	let { child, ...rest } = $props()
+
+	const Component = $derived(child)
 </script>
 
 <Canvas>
-	<svelte:component
-		this={child}
-		{...rest}
-	/>
+	<Component {...rest} />
 </Canvas>

package/dist/components/Selected.svelte

@@ -1,11 +1,13 @@
 <script lang="ts">
-	import { T, useTask } from '@threlte/core'
+	import { T, useTask, useThrelte } from '@threlte/core'
 	import { useSelectedObject, useSelectedObject3d } from '../hooks/useSelection.svelte'
 	import { OBBHelper } from '../three/OBBHelper'
 	import { OBB } from 'three/addons/math/OBB.js'
 
 	const obb = new OBB()
 	const obbHelper = new OBBHelper()
+
+	const { invalidate } = useThrelte()
 	const selected = useSelectedObject()
 	const selectedObject3d = useSelectedObject3d()
 
@@ -27,6 +29,7 @@
 			if (selected.current.metadata.batched) {
 				selected.current.metadata.getBoundingBoxAt?.(obb)
 				obbHelper.setFromOBB(obb)
+				invalidate()
 				return
 			}
 
@@ -34,6 +37,7 @@
 				selectedObject3d.current?.getWorldPosition(clone.position)
 				selectedObject3d.current?.getWorldQuaternion(clone.quaternion)
 				obbHelper.setFromObject(clone)
+				invalidate()
 			}
 		},
 		{
@@ -48,8 +52,11 @@
 			obbHelper.visible = true
 		} else {
 			stop()
+
 			obbHelper.visible = false
 		}
+
+		invalidate()
 	})
 </script>
 

package/dist/components/Tree/Logs.svelte

@@ -1,37 +1,8 @@
 <script lang="ts">
-	import { useFrames } from '../../hooks/useFrames.svelte'
-	import { useGeometries } from '../../hooks/useGeometries.svelte'
 	import { useLogs } from '../../hooks/useLogs.svelte'
-	import { usePointClouds } from '../../hooks/usePointclouds.svelte'
 	import Drawer from './Drawer.svelte'
 
-	const frames = useFrames()
-	const geometries = useGeometries()
-	const pointclouds = usePointClouds()
 	const logs = useLogs()
-
-	$effect(() => {
-		if (frames.error) {
-			const message = `Frames: ${frames.error.message}`
-			logs.add(message, 'error')
-		}
-	})
-
-	$effect(() => {
-		if (geometries.errors.length > 0) {
-			for (const error of geometries.errors) {
-				logs.add(`Geometries: ${error.message}`, 'error')
-			}
-		}
-	})
-
-	$effect(() => {
-		if (pointclouds.errors.length > 0) {
-			for (const error of pointclouds.errors) {
-				logs.add(`Pointclouds: ${error.message}`, 'error')
-			}
-		}
-	})
 </script>
 
 <Drawer name="Logs">

package/dist/components/Tree/Logs.svelte.d.ts

@@ -1,3 +1,18 @@
-declare const Logs: import("svelte").Component<Record<string, never>, {}, "">;
-type Logs = ReturnType<typeof Logs>;
+interface $$__sveltets_2_IsomorphicComponent<Props extends Record<string, any> = any, Events extends Record<string, any> = any, Slots extends Record<string, any> = any, Exports = {}, Bindings = string> {
+    new (options: import('svelte').ComponentConstructorOptions<Props>): import('svelte').SvelteComponent<Props, Events, Slots> & {
+        $$bindings?: Bindings;
+    } & Exports;
+    (internal: unknown, props: {
+        $$events?: Events;
+        $$slots?: Slots;
+    }): Exports & {
+        $set?: any;
+        $on?: any;
+    };
+    z_$$bindings?: Bindings;
+}
+declare const Logs: $$__sveltets_2_IsomorphicComponent<Record<string, never>, {
+    [evt: string]: CustomEvent<any>;
+}, {}, {}, string>;
+type Logs = InstanceType<typeof Logs>;
 export default Logs;

package/dist/components/Tree/Settings.svelte

@@ -1,6 +1,5 @@
 <script lang="ts">
 	import { Select, Switch, Input } from '@viamrobotics/prime-core'
-	import { useQueryClient } from '@tanstack/svelte-query'
 	import RefreshRate from '../RefreshRate.svelte'
 	import { useMotionClient } from '../../hooks/useMotionClient.svelte'
 	import Drawer from './Drawer.svelte'
@@ -10,13 +9,31 @@
 	import { RefreshRates, useMachineSettings } from '../../hooks/useMachineSettings.svelte'
 	import WeblabActive from '../weblab/WeblabActive.svelte'
 	import { WEBLABS_EXPERIMENTS } from '../../hooks/useWeblabs.svelte'
+	import { useGeometries } from '../../hooks/useGeometries.svelte'
+	import { usePointClouds } from '../../hooks/usePointclouds.svelte'
+	import { useThrelte } from '@threlte/core'
+	import { useRefetchPoses } from '../../hooks/useRefetchPoses'
 
-	const queryClient = useQueryClient()
+	const { invalidate } = useThrelte()
 	const partID = usePartID()
 	const cameras = useResourceNames(() => partID.current, 'camera')
 	const settings = useSettings()
 	const { disabledCameras } = useMachineSettings()
 	const motionClient = useMotionClient()
+	const geometries = useGeometries()
+	const pointclouds = usePointClouds()
+
+	const { refetchPoses } = useRefetchPoses()
+
+	// Invalidate the renderer for any settings change
+	$effect(() => {
+		for (const key in settings.current) {
+			// eslint-disable-next-line @typescript-eslint/no-unused-expressions
+			settings.current[key as keyof typeof settings.current]
+		}
+
+		invalidate()
+	})
 </script>
 
 <Drawer
@@ -31,14 +48,15 @@
 			label="Poses"
 			allowLive
 			onManualRefetch={() => {
-				queryClient.refetchQueries({ queryKey: ['getPose', 'getGeometries'], exact: false })
+				refetchPoses()
+				geometries.refetch()
 			}}
 		/>
 		<RefreshRate
 			id={RefreshRates.pointclouds}
 			label="Pointclouds"
 			onManualRefetch={() => {
-				queryClient.refetchQueries({ queryKey: ['getPointCloud'], exact: false })
+				pointclouds.refetch()
 			}}
 		/>
 		<div>

package/dist/components/Tree/Settings.svelte.d.ts

@@ -1,18 +1,3 @@
-interface $$__sveltets_2_IsomorphicComponent<Props extends Record<string, any> = any, Events extends Record<string, any> = any, Slots extends Record<string, any> = any, Exports = {}, Bindings = string> {
-    new (options: import('svelte').ComponentConstructorOptions<Props>): import('svelte').SvelteComponent<Props, Events, Slots> & {
-        $$bindings?: Bindings;
-    } & Exports;
-    (internal: unknown, props: {
-        $$events?: Events;
-        $$slots?: Slots;
-    }): Exports & {
-        $set?: any;
-        $on?: any;
-    };
-    z_$$bindings?: Bindings;
-}
-declare const Settings: $$__sveltets_2_IsomorphicComponent<Record<string, never>, {
-    [evt: string]: CustomEvent<any>;
-}, {}, {}, string>;
-type Settings = InstanceType<typeof Settings>;
+declare const Settings: import("svelte").Component<Record<string, never>, {}, "">;
+type Settings = ReturnType<typeof Settings>;
 export default Settings;

package/dist/hooks/useArmClient.svelte.js

@@ -1,4 +1,4 @@
-import { ArmClient, ArmJointPositions } from '@viamrobotics/sdk';
+import { ArmClient } from '@viamrobotics/sdk';
 import { createResourceClient, createResourceQuery, useResourceNames, } from '@viamrobotics/svelte-sdk';
 import { getContext, setContext } from 'svelte';
 const key = Symbol('arm-client-context');
@@ -7,20 +7,8 @@ export const provideArmClient = (partID) => {
     const options = { refetchInterval: 500 };
     const names = $derived(arms.current.map((arm) => arm.name));
     const clients = $derived(arms.current.map((arm) => createResourceClient(ArmClient, partID, () => arm.name)));
-    const jointPositionsQueries = $derived.by(() => {
-        const results = {};
-        for (const client of clients) {
-            if (!client.current)
-                continue;
-            const query = createResourceQuery(client, 'getJointPositions', options);
-            results[client.current.name] = query;
-        }
-        return results;
-    });
-    const currentPositions = $derived(Object.fromEntries(Object.entries(jointPositionsQueries).map(([name, query]) => [
-        name,
-        query.current.data?.values,
-    ])));
+    const jointPositionsQueries = $derived(clients.map((client) => [client.current?.name, createResourceQuery(client, 'getJointPositions', options)]));
+    const currentPositions = $derived(Object.fromEntries(jointPositionsQueries.map(([name, query]) => [name, query.data?.values])));
     setContext(key, {
         get names() {
             return names;

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

@@ -1,8 +1,6 @@
 import { WorldObject } from '../WorldObject.svelte';
 interface FramesContext {
     current: WorldObject[];
-    error?: Error;
-    fetching: boolean;
     getParentFrameOptions: (componentName: string) => string[];
 }
 export declare const provideFrames: (partID: () => string) => void;

package/dist/hooks/useFrames.svelte.js

@@ -22,13 +22,16 @@ export const provideFrames = (partID) => {
     const { updateUUIDs } = usePersistentUUIDs();
     $effect.pre(() => {
         if (revision) {
-            untrack(() => query.current).refetch();
+            untrack(() => query.refetch());
         }
     });
-    $effect.pre(() => {
-        if (query.current.isFetching) {
+    $effect(() => {
+        if (query.isFetching) {
             logs.add('Fetching frames...');
         }
+        else if (query.error) {
+            logs.add(`Frames: ${query.error.message}`, 'error');
+        }
     });
     $effect.pre(() => {
         if (partConfig.isDirty) {
@@ -40,7 +43,7 @@ export const provideFrames = (partID) => {
     });
     const machineFrames = $derived.by(() => {
         const objects = {};
-        for (const { frame } of query.current.data ?? []) {
+        for (const { frame } of query.data ?? []) {
             if (frame === undefined) {
                 continue;
             }
@@ -140,8 +143,6 @@ export const provideFrames = (partID) => {
         updateUUIDs(results);
         return results;
     });
-    const error = $derived(query.current.error ?? undefined);
-    const fetching = $derived(query.current.isFetching);
     const getParentFrameOptions = (componentName) => {
         const validFrames = new Set(current.map((frame) => frame.name));
         validFrames.add('world');
@@ -163,12 +164,6 @@ export const provideFrames = (partID) => {
         get current() {
             return current;
         },
-        get error() {
-            return error;
-        },
-        get fetching() {
-            return fetching;
-        },
     });
 };
 export const useFrames = () => {

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

@@ -1,7 +1,7 @@
 import { WorldObject } from '../WorldObject.svelte';
 interface Context {
     current: WorldObject[];
-    errors: Error[];
+    refetch: () => void;
 }
 export declare const provideGeometries: (partID: () => string) => void;
 export declare const useGeometries: () => Context;

package/dist/hooks/useGeometries.svelte.js

@@ -1,65 +1,59 @@
-import { ArmClient, CameraClient, GantryClient, Geometry, GripperClient } from '@viamrobotics/sdk';
-import { createQueries, queryOptions } from '@tanstack/svelte-query';
-import { createResourceClient, useResourceNames } from '@viamrobotics/svelte-sdk';
+import { ArmClient, CameraClient, GantryClient, GripperClient } from '@viamrobotics/sdk';
+import { createResourceClient, createResourceQuery, useResourceNames, } from '@viamrobotics/svelte-sdk';
 import { setContext, getContext } from 'svelte';
-import { fromStore, toStore } from 'svelte/store';
 import { useMachineSettings, RefreshRates } from './useMachineSettings.svelte';
 import { WorldObject } from '../WorldObject.svelte';
 import { usePersistentUUIDs } from './usePersistentUUIDs.svelte';
 import { useLogs } from './useLogs.svelte';
 import { resourceColors } from '../color';
 import { Color } from 'three';
-import { useFrames } from './useFrames.svelte';
 import { RefetchRates } from '../components/RefreshRate.svelte';
+import { useResourceByName } from './useResourceByName.svelte';
 const key = Symbol('geometries-context');
 export const provideGeometries = (partID) => {
-    const frames = useFrames();
-    const resourceNames = useResourceNames(partID);
+    const logs = useLogs();
+    const resourceByName = useResourceByName();
     const arms = useResourceNames(partID, 'arm');
     const cameras = useResourceNames(partID, 'camera');
     const grippers = useResourceNames(partID, 'gripper');
     const gantries = useResourceNames(partID, 'gantry');
-    const logs = useLogs();
     const { refreshRates } = useMachineSettings();
     const armClients = $derived(arms.current.map((arm) => createResourceClient(ArmClient, partID, () => arm.name)));
     const gripperClients = $derived(grippers.current.map((gripper) => createResourceClient(GripperClient, partID, () => gripper.name)));
     const cameraClients = $derived(cameras.current.map((camera) => createResourceClient(CameraClient, partID, () => camera.name)));
     const gantryClients = $derived(gantries.current.map((gantry) => createResourceClient(GantryClient, partID, () => gantry.name)));
-    const clients = $derived([...armClients, ...gripperClients, ...cameraClients, ...gantryClients].filter((client) => {
-        return frames.current.some((frame) => frame.name === client.current?.name);
-    }));
     const options = $derived.by(() => {
         const interval = refreshRates.get(RefreshRates.poses);
-        const results = [];
-        for (const client of clients) {
-            const options = queryOptions({
-                enabled: interval !== RefetchRates.OFF && client.current !== undefined,
-                refetchInterval: interval === RefetchRates.MANUAL ? false : interval,
-                queryKey: ['getGeometries', 'partID', partID(), client.current?.name],
-                queryFn: async () => {
-                    if (!client.current) {
-                        throw new Error('No client');
-                    }
-                    logs.add(`Fetching geometries for ${client.current.name}...`);
-                    const geometries = await client.current.getGeometries();
-                    return { name: client.current.name, geometries };
-                },
-            });
-            results.push(options);
+        return {
+            enabled: refreshRates.get(RefreshRates.poses) !== RefetchRates.OFF,
+            refetchInterval: interval === RefetchRates.MANUAL ? false : interval,
+        };
+    });
+    const armQueries = $derived(armClients.map((client) => [client.current?.name, createResourceQuery(client, 'getGeometries', () => options)]));
+    const gripperQueries = $derived(gripperClients.map((client) => [client.current?.name, createResourceQuery(client, 'getGeometries', () => options)]));
+    const cameraQueries = $derived(cameraClients.map((client) => [client.current?.name, createResourceQuery(client, 'getGeometries', () => options)]));
+    const gantryQueries = $derived(gantryClients.map((client) => [client.current?.name, createResourceQuery(client, 'getGeometries', () => options)]));
+    $effect(() => {
+        for (const [name, query] of queries) {
+            if (query.isFetching) {
+                logs.add(`Fetching geometries for ${name}...`);
+            }
+            else if (query.error) {
+                logs.add(`Error fetching geometries from ${name}: ${query.error.message}`, 'error');
+            }
         }
-        return results;
     });
     const { updateUUIDs } = usePersistentUUIDs();
-    const queries = fromStore(createQueries({ queries: toStore(() => options) }));
-    const errors = $derived(queries.current.map((query) => query.error).filter((error) => error !== null));
+    const queries = $derived([...armQueries, ...gripperQueries, ...cameraQueries, ...gantryQueries]);
     const geometries = $derived.by(() => {
         const results = [];
-        for (const query of queries.current) {
-            if (!query.data)
+        for (const [name, query] of queries) {
+            if (!name || !query.data) {
                 continue;
-            for (const geometry of query.data.geometries) {
-                const resourceName = resourceNames.current.find((item) => item.name === query.data.name);
-                const worldObject = new WorldObject(geometry.label ? geometry.label : `${query.data.name} geometry`, undefined, query.data.name, geometry, resourceName
+            }
+            for (const geometry of query.data) {
+                const resourceName = resourceByName.current[name];
+                const worldObject = new WorldObject(geometry.label ? geometry.label : `${name} geometry`, undefined, name, geometry, resourceName
                     ? {
                         color: new Color(resourceColors[resourceName.subtype]),
                     }
@@ -74,8 +68,10 @@ export const provideGeometries = (partID) => {
         get current() {
             return geometries;
         },
-        get errors() {
-            return errors;
+        refetch() {
+            for (const [, query] of queries) {
+                query.refetch();
+            }
         },
     });
 };

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

@@ -1,7 +1,7 @@
 import { WorldObject, type PointsGeometry } from '../WorldObject.svelte';
 interface Context {
     current: WorldObject<PointsGeometry>[];
-    errors: Error[];
+    refetch: () => void;
 }
 export declare const providePointclouds: (partID: () => string) => void;
 export declare const usePointClouds: () => Context;

package/dist/hooks/usePointclouds.svelte.js

@@ -1,8 +1,6 @@
-import { createQueries, queryOptions } from '@tanstack/svelte-query';
 import { CameraClient } from '@viamrobotics/sdk';
 import { setContext, getContext } from 'svelte';
-import { fromStore, toStore } from 'svelte/store';
-import { createResourceClient, useResourceNames } from '@viamrobotics/svelte-sdk';
+import { createResourceClient, createResourceQuery, useResourceNames, } from '@viamrobotics/svelte-sdk';
 import { parsePcdInWorker } from '../loaders/pcd';
 import { RefreshRates, useMachineSettings } from './useMachineSettings.svelte';
 import { WorldObject } from '../WorldObject.svelte';
@@ -15,54 +13,85 @@ export const providePointclouds = (partID) => {
     const { refreshRates, disabledCameras } = useMachineSettings();
     const cameras = useResourceNames(partID, 'camera');
     const clients = $derived(cameras.current.map((camera) => createResourceClient(CameraClient, partID, () => camera.name)));
-    const options = $derived.by(() => {
-        const interval = refreshRates.get(RefreshRates.pointclouds);
-        const results = [];
-        for (const cameraClient of clients) {
-            const name = cameraClient.current?.name ?? '';
-            const options = queryOptions({
-                enabled: interval !== RefetchRates.OFF &&
-                    cameraClient.current !== undefined &&
-                    disabledCameras.get(name) !== true,
-                refetchInterval: interval === RefetchRates.MANUAL ? false : interval,
-                queryKey: ['getPointCloud', 'partID', partID(), name],
-                queryFn: async () => {
-                    if (!cameraClient.current) {
-                        throw new Error('No camera client');
-                    }
-                    logs.add(`Fetching pointcloud for ${cameraClient.current.name}`);
-                    const response = await cameraClient.current.getPointCloud();
-                    if (!response)
-                        return null;
-                    const { positions, colors } = await parsePcdInWorker(new Uint8Array(response));
-                    return new WorldObject(`${name}:pointcloud`, undefined, name, { center: undefined, geometryType: { case: 'points', value: positions } }, colors ? { colors } : undefined);
-                },
-            });
-            results.push(options);
+    const propQueries = $derived(clients.map((client) => [
+        client.current?.name,
+        createResourceQuery(client, 'getProperties', {
+            staleTime: Infinity,
+            refetchOnMount: false,
+            refetchInterval: false,
+        }),
+    ]));
+    const fetchedPropQueries = propQueries.every(([, query]) => query.isPending === false);
+    const interval = $derived(refreshRates.get(RefreshRates.pointclouds));
+    const enabledClients = $derived(clients.filter((client) => fetchedPropQueries &&
+        client.current?.name &&
+        interval !== RefetchRates.OFF &&
+        disabledCameras.get(client.current?.name) !== true));
+    /**
+     * Some machines have a lot of cameras, so before enabling all of them
+     * we'll first check pointcloud support.
+     *
+     * We'll disable cameras that don't support pointclouds,
+     * but still allow users to manually enable if they want to.
+     */
+    $effect(() => {
+        for (const [name, query] of propQueries) {
+            if (name && query.data?.supportsPcd === false) {
+                if (disabledCameras.get(name) === undefined) {
+                    disabledCameras.set(name, true);
+                }
+            }
         }
-        return results;
     });
+    const queries = $derived(enabledClients.map((client) => [
+        client.current?.name,
+        createResourceQuery(client, 'getPointCloud', () => ({ refetchInterval: interval })),
+    ]));
     const { updateUUIDs } = usePersistentUUIDs();
-    const queries = fromStore(createQueries({
-        queries: toStore(() => options),
-        combine: (results) => {
-            const data = results
-                .flatMap((result) => result.data)
-                .filter((data) => data !== null && data !== undefined);
-            const errors = results.flatMap((result) => result.error).filter((error) => error !== null);
-            updateUUIDs(data);
-            return {
-                data,
-                errors,
-            };
-        },
-    }));
+    let current = $state.raw([]);
+    $effect(() => {
+        for (const [name, query] of queries) {
+            if (query.isFetching) {
+                logs.add(`Fetching pointcloud for ${name}...`);
+            }
+            else if (query.error) {
+                logs.add(`Error fetching pointcloud from ${name}: ${query.error.message}`, 'error');
+            }
+        }
+    });
+    $effect(() => {
+        const binaries = [];
+        for (const [name, query] of queries) {
+            const { data } = query;
+            if (name && data) {
+                binaries.push([name, data]);
+            }
+        }
+        Promise.allSettled(binaries.map(async ([name, uint8array]) => {
+            const { positions, colors } = await parsePcdInWorker(new Uint8Array(uint8array));
+            return new WorldObject(`${name}:pointcloud`, undefined, name, { center: undefined, geometryType: { case: 'points', value: positions } }, colors ? { colors } : undefined);
+        })).then((results) => {
+            const worldObjects = [];
+            for (const result of results) {
+                if (result.status === 'fulfilled') {
+                    worldObjects.push(result.value);
+                }
+                else if (result.status === 'rejected') {
+                    logs.add(result.reason, 'error');
+                }
+            }
+            updateUUIDs(worldObjects);
+            current = worldObjects;
+        });
+    });
     setContext(key, {
         get current() {
-            return queries.current.data;
+            return current;
         },
-        get errors() {
-            return queries.current.errors;
+        refetch() {
+            for (const [, query] of queries) {
+                query.refetch();
+            }
         },
     });
 };

package/dist/hooks/usePose.svelte.js

@@ -1,9 +1,7 @@
-import { createResourceClient, useResourceNames } from '@viamrobotics/svelte-sdk';
+import { createResourceClient, createResourceQuery } from '@viamrobotics/svelte-sdk';
 import { usePartID } from './usePartID.svelte';
-import { MotionClient } from '@viamrobotics/sdk';
-import { createQuery, queryOptions } from '@tanstack/svelte-query';
+import { MotionClient, Transform } from '@viamrobotics/sdk';
 import { RefreshRates, useMachineSettings } from './useMachineSettings.svelte';
-import { fromStore, toStore } from 'svelte/store';
 import { useMotionClient } from './useMotionClient.svelte';
 import { useEnvironment } from './useEnvironment.svelte';
 import { observe } from '@threlte/core';
@@ -11,43 +9,40 @@ import { untrack } from 'svelte';
 import { useFrames } from './useFrames.svelte';
 import { RefetchRates } from '../components/RefreshRate.svelte';
 import { useLogs } from './useLogs.svelte';
+import { useResourceByName } from './useResourceByName.svelte';
+import { useRefetchPoses } from './useRefetchPoses';
 export const usePose = (name, parent) => {
     const logs = useLogs();
     const { refreshRates } = useMachineSettings();
     const partID = usePartID();
     const motionClient = useMotionClient();
-    const resources = useResourceNames(() => partID.current);
-    const resource = $derived(resources.current.find((resource) => resource.name === name()));
-    const parentResource = $derived(resources.current.find((resource) => resource.name === parent()));
+    const currentName = $derived(name());
+    const currentParent = $derived(parent());
+    const resourceByName = useResourceByName();
+    const { addQueryToRefetch } = useRefetchPoses();
+    const resource = $derived(resourceByName.current[currentName]);
+    const parentResource = $derived(currentParent ? resourceByName.current[currentParent] : undefined);
     const environment = useEnvironment();
     const frames = useFrames();
     const client = createResourceClient(MotionClient, () => partID.current, () => motionClient.current ?? '');
     const interval = $derived(refreshRates.get(RefreshRates.poses));
-    const options = $derived(queryOptions({
-        enabled: interval !== RefetchRates.OFF &&
-            client.current !== undefined &&
-            environment.current.viewerMode === 'monitor',
+    const resolvedParent = $derived(parentResource?.subtype === 'arm' ? `${parent()}_origin` : parent());
+    const query = createResourceQuery(client, 'getPose', () => [currentName, resolvedParent ?? 'world', []], () => ({
+        enabled: interval !== RefetchRates.OFF,
         refetchInterval: interval === RefetchRates.MANUAL ? false : interval,
-        queryKey: ['getPose', 'partID', partID.current, client.current?.name, name(), parent()],
-        queryFn: async () => {
-            if (!client.current) {
-                throw new Error('No client');
-            }
-            logs.add(`Fetching pose for ${name()}...`);
-            const resolvedParent = parentResource?.subtype === 'arm' ? `${parent()}_origin` : parent();
-            const pose = await client.current.getPose(name(), resolvedParent ?? 'world', []);
-            return pose;
-        },
     }));
-    const query = fromStore(createQuery(toStore(() => options)));
-    observe.pre(() => [environment.current.viewerMode, frames.current], () => {
-        if (environment.current.viewerMode === 'monitor') {
-            untrack(() => query.current).refetch();
+    $effect(() => addQueryToRefetch(query));
+    $effect(() => {
+        if (query.isFetching) {
+            logs.add(`Fetching pose for ${currentName}...`);
+        }
+        else if (query.error) {
+            logs.add(`Error fetching pose for ${currentName}: ${query.error.message}`, 'error');
         }
     });
-    $effect(() => {
-        if (query.current.error) {
-            logs.add(query.current.error.message, 'error');
+    observe.pre(() => [environment.current.viewerMode, frames.current], () => {
+        if (environment.current.viewerMode === 'monitor') {
+            untrack(() => query.refetch());
         }
     });
     return {
@@ -59,7 +54,7 @@ export const usePose = (name, parent) => {
             if (resource?.subtype === 'arm') {
                 return;
             }
-            return query.current.data?.pose;
+            return query.data?.pose;
         },
     };
 };

package/dist/hooks/useRefetchPoses.d.ts

@@ -0,0 +1,8 @@
+type RefetchFn = () => void;
+export declare const useRefetchPoses: () => {
+    addQueryToRefetch: (query: {
+        refetch: RefetchFn;
+    }) => () => boolean;
+    refetchPoses: () => void;
+};
+export {};

package/dist/hooks/useRefetchPoses.js

@@ -0,0 +1,16 @@
+const queries = new Set();
+const addQueryToRefetch = (query) => {
+    queries.add(query);
+    return () => queries.delete(query);
+};
+const refetchPoses = () => {
+    for (const query of queries) {
+        query.refetch();
+    }
+};
+export const useRefetchPoses = () => {
+    return {
+        addQueryToRefetch,
+        refetchPoses,
+    };
+};

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

@@ -1,6 +1,6 @@
 import type { ResourceName } from '@viamrobotics/sdk';
 interface Context {
-    current: Record<string, ResourceName>;
+    current: Record<string, ResourceName | undefined>;
 }
 export declare const provideResourceByName: (partID: () => string) => void;
 export declare const useResourceByName: () => Context;

package/dist/hooks/useWorldState.svelte.js

@@ -39,7 +39,7 @@ const createWorldState = (partID, resourceName) => {
     let pendingEvents = [];
     let flushScheduled = false;
     const listUUIDs = createResourceQuery(client, 'listUUIDs');
-    const getTransforms = $derived(listUUIDs.current.data?.map((uuid) => {
+    const getTransforms = $derived(listUUIDs.data?.map((uuid) => {
         return createResourceQuery(client, 'getTransform', () => [uuid], () => ({ refetchInterval: false }));
     }));
     const changeStream = createResourceStream(client, 'streamTransformChanges', {
@@ -99,10 +99,9 @@ const createWorldState = (partID, resourceName) => {
             return;
         if (initialized)
             return;
-        const queries = getTransforms.map((query) => query.current);
-        if (queries.some((query) => query?.isLoading))
+        if (getTransforms.some((query) => query?.isLoading))
             return;
-        const data = queries
+        const data = getTransforms
             .flatMap((query) => query?.data ?? [])
             .filter((transform) => transform !== undefined);
         if (data.length === 0)
@@ -124,9 +123,9 @@ const createWorldState = (partID, resourceName) => {
         };
     });
     $effect.pre(() => {
-        if (changeStream.current?.data === undefined)
+        if (changeStream?.data === undefined)
             return;
-        const events = changeStream.current.data.filter((event) => event.transform !== undefined);
+        const events = changeStream.data.filter((event) => event.transform !== undefined);
         if (events.length === 0)
             return;
         worker.postMessage({ type: 'change', events });
@@ -142,10 +141,10 @@ const createWorldState = (partID, resourceName) => {
             return worldObjectsList;
         },
         get listUUIDs() {
-            return listUUIDs.current;
+            return listUUIDs;
         },
         get getTransforms() {
-            return getTransforms?.map((query) => query.current);
+            return getTransforms;
         },
     };
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@viamrobotics/motion-tools",
-  "version": "0.18.3",
+  "version": "0.19.0",
   "description": "Motion visualization with Viam",
   "license": "Apache-2.0",
   "type": "module",
@@ -22,8 +22,6 @@
     "@sveltejs/vite-plugin-svelte": "6.1.4",
     "@tailwindcss/forms": "0.5.10",
     "@tailwindcss/vite": "4.1.13",
-    "@tanstack/svelte-query": "5.87.1",
-    "@tanstack/svelte-query-devtools": "5.87.3",
     "@testing-library/jest-dom": "6.8.0",
     "@testing-library/svelte": "5.2.8",
     "@thi.ng/paths": "5.2.21",
@@ -37,8 +35,8 @@
     "@typescript-eslint/eslint-plugin": "8.42.0",
     "@typescript-eslint/parser": "8.42.0",
     "@viamrobotics/prime-core": "0.1.5",
-    "@viamrobotics/sdk": "0.55.0",
-    "@viamrobotics/svelte-sdk": "0.7.1",
+    "@viamrobotics/sdk": "0.56.0",
+    "@viamrobotics/svelte-sdk": "1.0.1",
     "@vitejs/plugin-basic-ssl": "2.1.0",
     "@vitest/coverage-v8": "^3.2.4",
     "@zag-js/svelte": "1.22.1",
@@ -75,7 +73,6 @@
   },
   "peerDependencies": {
     "@dimforge/rapier3d-compat": ">=0.17",
-    "@tanstack/svelte-query": ">=5",
     "@threlte/core": ">=8",
     "@threlte/extras": ">=9",
     "@threlte/rapier": ">=3",
@@ -119,6 +116,9 @@
     "!dist/**/*.test.*",
     "!dist/**/*.spec.*"
   ],
+  "dependencies": {
+    "@tanstack/svelte-query-devtools": "^6.0.2"
+  },
   "scripts": {
     "dev": "tsx server/check-bun && bun run server/server.ts",
     "build": "vite build && npm run prepack",