@viamrobotics/motion-tools 1.33.0 → 1.33.2

package/dist/ecs/traits.d.ts

@@ -71,7 +71,7 @@ export declare const Invisible: import("koota").Trait<() => boolean>;
  * `details-extensions` portal target (e.g. gizmo plugin entities) opt in by
  * adding this trait.
  */
-export declare const CustomDetails: import("koota").Trait<() => boolean>;
+export declare const CustomDetails: import("koota").TagTrait;
 /**
  * True when the entity itself, or any of its parents up the `ChildOf`
  * chain, has `Invisible`. Maintained by `provideInheritedInvisible`;

package/dist/ecs/traits.js

@@ -68,7 +68,7 @@ export const Invisible = trait(() => true);
  * `details-extensions` portal target (e.g. gizmo plugin entities) opt in by
  * adding this trait.
  */
-export const CustomDetails = trait(() => true);
+export const CustomDetails = trait();
 /**
  * True when the entity itself, or any of its parents up the `ChildOf`
  * chain, has `Invisible`. Maintained by `provideInheritedInvisible`;

package/dist/hooks/usePartConfig.svelte.js

@@ -105,12 +105,14 @@ export const providePartConfig = (partID, params) => {
                 y: pose.y ?? currentPose.y,
                 z: pose.z ?? currentPose.z,
             };
-            component.frame.orientation.type = 'ov_degrees';
-            component.frame.orientation.value = {
-                x: pose.oX ?? currentPose.oX,
-                y: pose.oY ?? currentPose.oY,
-                z: pose.oZ ?? currentPose.oZ,
-                th: pose.theta ?? currentPose.theta,
+            component.frame.orientation = {
+                type: 'ov_degrees',
+                value: {
+                    x: pose.oX ?? currentPose.oX,
+                    y: pose.oY ?? currentPose.oY,
+                    z: pose.oZ ?? currentPose.oZ,
+                    th: pose.theta ?? currentPose.theta,
+                },
             };
             if (geometry) {
                 if (geometry.type === 'none') {

package/dist/hooks/useWorldState.svelte.js

@@ -1,11 +1,11 @@
 import { useThrelte } from '@threlte/core';
 import { Struct, TransformChangeType, WorldStateStoreClient, } from '@viamrobotics/sdk';
-import { createResourceClient, createResourceQuery, createResourceStream, useResourceNames, } from '@viamrobotics/svelte-sdk';
+import { createResourceClient, createResourceQuery, useResourceNames, } from '@viamrobotics/svelte-sdk';
 import { Matrix4 } from 'three';
 import { asFloat32Array, inMeters } from '../buffer';
 import { createChunkLoader } from '../chunking';
 import { drawTransform, updateMetadata } from '../draw';
-import { traits, useWorld } from '../ecs';
+import { hierarchy, traits, useWorld } from '../ecs';
 import { isPointCloud } from '../geometry';
 import { metadataFromStruct } from '../metadata';
 import { createPose, poseToMatrix } from '../transform';
@@ -27,6 +27,10 @@ export const provideWorldStates = () => {
         };
     });
 };
+// FieldMask paths are proto field names; spec-compliant backends emit
+// snake_case (`pose_in_observer_frame`) while some emit camelCase. Normalize
+// to camelCase so matching against the message's accessors is casing-agnostic.
+const snakeToCamel = (path) => path.replaceAll(/_([a-z])/g, (_, char) => char.toUpperCase());
 const decodeBase64 = (encoded) => {
     const binary = atob(encoded);
     const bytes = new Uint8Array(binary.length);
@@ -87,6 +91,11 @@ const createWorldState = (client) => {
     const world = useWorld();
     const relationships = useRelationships();
     const entities = new Map();
+    // UUIDs the stream has removed; guards against a stale initial snapshot or a
+    // self-heal fetch re-creating an entity the server has already deleted.
+    const removedUUIDs = new Set();
+    // UUIDs with an in-flight self-heal `getTransform`, to dedupe concurrent fetches.
+    const pendingSpawns = new Set();
     const chunkLoader = createChunkLoader({
         world,
         invalidate,
@@ -105,7 +114,7 @@ const createWorldState = (client) => {
         },
     });
     const spawnEntity = (transform) => {
-        if (entities.has(transform.uuidString)) {
+        if (entities.has(transform.uuidString) || removedUUIDs.has(transform.uuidString)) {
             return;
         }
         const spawned = drawTransform(world, transform, traits.WorldStateStoreAPI, { removable: false });
@@ -118,6 +127,7 @@ const createWorldState = (client) => {
             invalidate();
     };
     const destroyEntity = (uuid) => {
+        removedUUIDs.add(uuid);
         const entity = entities.get(uuid);
         if (!entity)
             return;
@@ -126,29 +136,54 @@ const createWorldState = (client) => {
         }
         entities.delete(uuid);
     };
+    // Spawn an entity whose UPDATE delta arrived before the initial snapshot
+    // created it. The delta carries only changed fields, so fetch the full
+    // transform; skip if it was removed or already spawned meanwhile.
+    const spawnFromServer = async (uuid) => {
+        if (entities.has(uuid) || removedUUIDs.has(uuid) || pendingSpawns.has(uuid))
+            return;
+        pendingSpawns.add(uuid);
+        try {
+            const transform = await client.current?.getTransform(uuid);
+            if (transform && !removedUUIDs.has(uuid)) {
+                spawnEntity(transform);
+                invalidate();
+            }
+        }
+        catch (error) {
+            console.error('World state self-heal failed for', uuid, error);
+        }
+        finally {
+            pendingSpawns.delete(uuid);
+        }
+    };
     const updateEntity = (transform, changes) => {
         const entity = entities.get(transform.uuidString);
-        if (!entity)
+        if (!entity) {
+            void spawnFromServer(transform.uuidString);
             return;
+        }
         let metadataDirty = false;
-        for (const path of changes) {
-            if (typeof path === 'string') {
-                if (path.startsWith('poseInObserverFrame.pose')) {
-                    const matrix = entity.get(traits.Matrix);
-                    if (matrix) {
-                        poseToMatrix(createPose(transform.poseInObserverFrame?.pose), matrix);
-                        entity.changed(traits.Matrix);
-                    }
-                    else {
-                        entity.add(traits.Matrix(poseToMatrix(createPose(transform.poseInObserverFrame?.pose), new Matrix4())));
-                    }
-                }
-                else if (path.startsWith('physicalObject') && transform.physicalObject) {
-                    traits.updateGeometryTrait(entity, transform.physicalObject);
+        for (const rawPath of changes) {
+            if (typeof rawPath !== 'string')
+                continue;
+            const path = snakeToCamel(rawPath);
+            if (path.startsWith('poseInObserverFrame')) {
+                const matrix = entity.get(traits.Matrix);
+                if (matrix) {
+                    poseToMatrix(createPose(transform.poseInObserverFrame?.pose), matrix);
+                    entity.changed(traits.Matrix);
                 }
-                else if (path.startsWith('metadata')) {
-                    metadataDirty = true;
+                else {
+                    entity.add(traits.Matrix(poseToMatrix(createPose(transform.poseInObserverFrame?.pose), new Matrix4())));
                 }
+                hierarchy.setParent(entity, transform.poseInObserverFrame?.referenceFrame);
+            }
+            else if (path.startsWith('physicalObject') && transform.physicalObject) {
+                traits.updateGeometryTrait(entity, transform.physicalObject);
+            }
+            else if (path.startsWith('metadata')) {
+                metadataDirty = true;
             }
         }
         if (metadataDirty) {
@@ -161,17 +196,16 @@ const createWorldState = (client) => {
     };
     let initialized = false;
     let flushScheduled = false;
+    let rafId = 0;
     let pendingEvents = [];
     const listUUIDs = createResourceQuery(client, 'listUUIDs');
     const getTransformQueries = $derived(listUUIDs.data?.map((uuid) => {
         return createResourceQuery(client, 'getTransform', () => [uuid], () => ({ refetchInterval: false }));
     }));
-    const changeStream = createResourceStream(client, 'streamTransformChanges', {
-        refetchMode: 'replace',
-    });
     const applyEvents = (events) => {
         for (const event of events) {
             if (event.changeType === TransformChangeType.ADDED) {
+                removedUUIDs.delete(event.transform.uuidString);
                 spawnEntity(event.transform);
             }
             else if (event.changeType === TransformChangeType.REMOVED) {
@@ -190,11 +224,12 @@ const createWorldState = (client) => {
         if (flushScheduled)
             return;
         flushScheduled = true;
-        requestAnimationFrame(() => {
-            const toApply = pendingEvents;
-            applyEvents(toApply);
+        rafId = requestAnimationFrame(() => {
+            rafId = 0;
             flushScheduled = false;
+            const toApply = pendingEvents;
             pendingEvents = [];
+            applyEvents(toApply);
         });
     };
     $effect(() => {
@@ -213,55 +248,45 @@ const createWorldState = (client) => {
         invalidate();
         initialized = true;
     });
-    $effect(() => {
-        if (changeStream?.data === undefined)
+    /**
+     * Consumes the `streamTransformChanges` server stream directly.
+     * Transform changes are write-once into the ECS world, so we drain
+     * each event into `pendingEvents` (cleared every flush) and never
+     * retain history. Mirrors `useDrawService`'s stream consumption.
+     */
+    const consumeChanges = async (signal) => {
+        const activeClient = client.current;
+        if (!activeClient)
             return;
-        const eventsByUUID = new Map();
-        for (const event of changeStream.data) {
-            if (!event.transform) {
-                continue;
-            }
-            const uuid = event.transform.uuidString;
-            const existing = eventsByUUID.get(uuid);
-            if (!existing) {
-                eventsByUUID.set(uuid, event);
-                continue;
-            }
-            switch (event.changeType) {
-                case TransformChangeType.REMOVED: {
-                    eventsByUUID.set(uuid, event);
-                    break;
-                }
-                case TransformChangeType.ADDED: {
-                    if (existing.changeType !== TransformChangeType.REMOVED) {
-                        eventsByUUID.set(uuid, event);
-                    }
-                    break;
-                }
-                case TransformChangeType.UPDATED: {
-                    // merge with existing updated event
-                    if (existing.changeType === TransformChangeType.UPDATED) {
-                        existing.updatedFields ??= { paths: [] };
-                        const paths = event.updatedFields?.paths ?? [];
-                        for (const path of paths) {
-                            if (existing.updatedFields.paths.includes(path)) {
-                                continue;
-                            }
-                            existing.updatedFields.paths.push(path);
-                        }
-                        existing.transform = event.transform;
-                    }
-                    else {
-                        eventsByUUID.set(uuid, event);
-                    }
+        try {
+            for await (const event of activeClient.streamTransformChanges(undefined, { signal })) {
+                if (signal.aborted)
                     break;
-                }
+                if (!event.transform)
+                    continue;
+                pendingEvents.push(event);
+                scheduleFlush();
+            }
+        }
+        catch (error) {
+            if (!signal.aborted) {
+                console.error('World state transform stream error:', error);
             }
         }
-        pendingEvents.push(...eventsByUUID.values());
-        scheduleFlush();
+    };
+    $effect(() => {
+        if (!client.current)
+            return;
+        const controller = new AbortController();
+        void consumeChanges(controller.signal);
+        return () => {
+            controller.abort();
+        };
     });
     return () => {
+        if (rafId)
+            cancelAnimationFrame(rafId);
+        pendingEvents = [];
         chunkLoader.dispose();
         for (const [, entity] of entities) {
             if (world.has(entity)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@viamrobotics/motion-tools",
-  "version": "1.33.0",
+  "version": "1.33.2",
   "description": "Motion visualization with Viam",
   "license": "Apache-2.0",
   "type": "module",
@@ -33,6 +33,7 @@
     "@threlte/rapier": "3.4.1",
     "@threlte/xr": "1.6.0",
     "@types/bun": "1.2.21",
+    "@types/d3-force": "^3.0.10",
     "@types/earcut": "^3.0.0",
     "@types/lodash-es": "4.17.12",
     "@types/node": "^25.6.0",
@@ -84,7 +85,7 @@
     "vite-plugin-devtools-json": "1.0.0",
     "vite-plugin-glsl": "^1.5.5",
     "vite-plugin-mkcert": "1.17.9",
-    "vitest": "3.2.4"
+    "vitest": "3.2.6"
   },
   "peerDependencies": {
     "@ag-grid-community/client-side-row-model": ">=32.3.0",
@@ -163,6 +164,7 @@
   "dependencies": {
     "@bufbuild/protobuf": "1.10.1",
     "@neodrag/svelte": "^2.3.3",
+    "d3-force": "^3.0.0",
     "filtrex": "^3.1.0",
     "koota": "0.6.5",
     "lodash-es": "4.18.1",