@viamrobotics/motion-tools 1.18.1 → 1.19.1

package/dist/hooks/usePartConfig.svelte.js

@@ -94,7 +94,6 @@ export const providePartConfig = (partID, params) => {
     const updatePartFrame = (componentName, referenceFrame, pose, geometry) => {
         const newConfig = getCurrent();
         const component = newConfig.components?.find(({ name }) => name === componentName);
-        console.log('hi', newConfig, componentName);
         if (!component) {
             return;
         }
@@ -162,6 +161,9 @@ export const providePartConfig = (partID, params) => {
         get isDirty() {
             return config.isDirty;
         },
+        get hasPendingSave() {
+            return config.hasPendingSave;
+        },
         get hasEditPermissions() {
             return config.hasEditPermissions;
         },
@@ -194,6 +196,8 @@ export const providePartConfig = (partID, params) => {
         },
         save: () => config.save?.(),
         discardChanges: () => config.discardChanges?.(),
+        clearPendingSave: () => config.clearPendingSave(),
+        setPendingSave: () => config.setPendingSave(),
     });
 };
 export const usePartConfig = () => {
@@ -202,6 +206,7 @@ export const usePartConfig = () => {
 const useEmbeddedPartConfig = (props) => {
     return {
         hasEditPermissions: true,
+        hasPendingSave: false,
         get isDirty() {
             return props.isDirty;
         },
@@ -215,6 +220,8 @@ const useEmbeddedPartConfig = (props) => {
             const struct = Struct.fromJson(config);
             return props.setLocalPartConfig(struct);
         },
+        clearPendingSave() { },
+        setPendingSave() { },
     };
 };
 const useStandalonePartConfig = (partID) => {
@@ -222,21 +229,25 @@ const useStandalonePartConfig = (partID) => {
         refetchInterval: false,
     });
     const partName = $derived(partQuery.data?.part?.name);
+    // Use part.robotConfig (the stored Struct config) as the authoritative source.
+    // configJson is the compiled running config from the robot daemon and may be empty
+    // even when the stored config exists and the API key has edit permissions.
+    let networkPartConfig = $derived(partQuery.data?.part?.robotConfig);
+    let current = $state.raw();
+    let isDirty = $state(false);
+    let hasPendingSave = $state(false);
+    const hasEditPermissions = $derived(networkPartConfig !== undefined);
     const configJSON = $derived.by(() => {
-        if (!partQuery.data?.configJson) {
+        if (!networkPartConfig) {
             return undefined;
         }
         try {
-            return JSON.parse(partQuery.data.configJson);
+            return networkPartConfig.toJson();
         }
         catch {
             return undefined;
         }
     });
-    let networkPartConfig = $derived(configJSON ? Struct.fromJson(configJSON) : undefined);
-    let current = $state.raw();
-    let isDirty = $state(false);
-    const hasEditPermissions = $derived(networkPartConfig !== undefined);
     const fragmentQueries = $derived((configJSON?.fragments ?? []).map((fragmentId) => {
         const id = typeof fragmentId === 'string' ? fragmentId : fragmentId.id;
         return createAppQuery('getFragment', () => [id], { refetchInterval: false });
@@ -263,8 +274,7 @@ const useStandalonePartConfig = (partID) => {
         return results;
     });
     $effect.pre(() => {
-        if (!networkPartConfig) {
-            // no config returned here indicates this api key has no permission to update config
+        if (!networkPartConfig || isDirty) {
             return;
         }
         current = networkPartConfig;
@@ -277,6 +287,9 @@ const useStandalonePartConfig = (partID) => {
         get isDirty() {
             return isDirty;
         },
+        get hasPendingSave() {
+            return hasPendingSave;
+        },
         get hasEditPermissions() {
             return hasEditPermissions;
         },
@@ -294,10 +307,17 @@ const useStandalonePartConfig = (partID) => {
             networkPartConfig = current;
             await updateRobotPartMutation.mutateAsync([partID(), partName, current]);
             isDirty = false;
+            hasPendingSave = true;
         },
         discardChanges() {
             current = networkPartConfig;
             isDirty = false;
         },
+        clearPendingSave() {
+            hasPendingSave = false;
+        },
+        setPendingSave() {
+            hasPendingSave = true;
+        },
     };
 };

package/dist/hooks/usePointcloudObjects.svelte.js

@@ -5,7 +5,6 @@ import { createBufferGeometry, updateBufferGeometry } from '../attribute';
 import { ColorFormat } from '../buf/draw/v1/metadata_pb';
 import { RefetchRates } from '../components/overlay/RefreshRate.svelte';
 import { traits, useWorld } from '../ecs';
-import { updateGeometryTrait } from '../ecs/traits';
 import { parsePcdInWorker } from '../lib';
 import { createPose } from '../transform';
 import { useEnvironment } from './useEnvironment.svelte';
@@ -162,20 +161,18 @@ export const providePointcloudObjects = (partID) => {
                             const existing = entities.get(geometryLabel);
                             if (existing) {
                                 existing.set(traits.Center, center);
-                                updateGeometryTrait(existing, geometry);
+                                traits.updateGeometryTrait(existing, geometry);
                             }
                             else {
                                 const entityTraits = [
                                     traits.Name(geometryLabel),
+                                    ...traits.getParentTrait(geometriesInFrame.referenceFrame),
                                     traits.Center(center),
                                     traits.GeometriesAPI,
                                     traits.Geometry(geometry),
                                     traits.Opacity(0.2),
                                     traits.Color({ r: 0, g: 1, b: 0 }),
                                 ];
-                                if (geometriesInFrame.referenceFrame) {
-                                    entityTraits.push(traits.Parent(geometriesInFrame.referenceFrame));
-                                }
                                 const entity = world.spawn(...entityTraits);
                                 entities.set(geometryLabel, entity);
                             }

package/dist/hooks/useWorldState.svelte.js

@@ -1,11 +1,12 @@
 import { useThrelte } from '@threlte/core';
-import { TransformChangeType, WorldStateStoreClient, } from '@viamrobotics/sdk';
+import { Struct, TransformChangeType, WorldStateStoreClient, } from '@viamrobotics/sdk';
 import { createResourceClient, createResourceQuery, createResourceStream, useResourceNames, } from '@viamrobotics/svelte-sdk';
-import { drawTransform } from '../draw';
+import { asFloat32Array, inMeters } from '../buffer';
+import { createChunkLoader } from '../chunking';
+import { drawTransform, updateMetadata } from '../draw';
 import { traits, useWorld } from '../ecs';
-import { createBox, createCapsule, createSphere } from '../geometry';
 import { isPointCloud } from '../geometry';
-import { parsePlyInput } from '../ply';
+import { metadataFromStruct } from '../metadata';
 import { createPose } from '../transform';
 import { usePartID } from './usePartID.svelte';
 export const provideWorldStates = () => {
@@ -24,16 +25,90 @@ export const provideWorldStates = () => {
         };
     });
 };
+const decodeBase64 = (encoded) => {
+    const binary = atob(encoded);
+    const bytes = new Uint8Array(binary.length);
+    for (let i = 0; i < binary.length; i++) {
+        bytes[i] = binary.charCodeAt(i);
+    }
+    return bytes;
+};
+/**
+ * Unpacks a `get_entity_chunk` DoCommand response into the shape the shared
+ * chunk loader expects. The world-state store sends binary buffers as base64
+ * strings inside a JSON `Struct`, which is why this adapter exists.
+ *
+ * Request:
+ *   { "command": "get_entity_chunk", "uuid": "<uuid-string>", "start": <element-offset> }
+ *
+ * Response:
+ *   {
+ *     "entity": {
+ *       "metadata": {
+ *         "colors":    "<base64 Uint8Array>" (optional),
+ *         "opacities": "<base64 Uint8Array>" (optional)
+ *       },
+ *       "physical_object": {
+ *         "points": { "positions": "<base64 Float32Array>" }
+ *       }
+ *     },
+ *     "start": <number>,
+ *     "done":  <boolean>
+ *   }
+ */
+const decodeWorldStateChunk = (response, fallbackStart) => {
+    const fields = response;
+    const done = fields['done'] === true;
+    const start = typeof fields['start'] === 'number' ? fields['start'] : fallbackStart;
+    const chunkEntity = fields['entity'];
+    if (!chunkEntity)
+        return null;
+    const physicalObject = chunkEntity['physical_object'];
+    const points = physicalObject?.['points'];
+    const encodedPositions = points?.['positions'];
+    if (typeof encodedPositions !== 'string' || encodedPositions.length === 0)
+        return null;
+    const positions = asFloat32Array(decodeBase64(encodedPositions), inMeters);
+    const metadata = chunkEntity['metadata'];
+    const encodedColors = metadata?.['colors'];
+    const colors = typeof encodedColors === 'string' && encodedColors.length > 0
+        ? decodeBase64(encodedColors)
+        : undefined;
+    const encodedOpacities = metadata?.['opacities'];
+    const opacities = typeof encodedOpacities === 'string' && encodedOpacities.length > 0
+        ? decodeBase64(encodedOpacities)
+        : undefined;
+    return { start, positions, colors, opacities, done };
+};
 const createWorldState = (client) => {
     const { invalidate } = useThrelte();
     const world = useWorld();
     const entities = new Map();
+    const chunkLoader = createChunkLoader({
+        world,
+        invalidate,
+        fetchChunk: async (uuid, start, signal) => {
+            const activeClient = client.current;
+            if (!activeClient)
+                return null;
+            const response = await activeClient.doCommand(Struct.fromJson({
+                command: 'get_entity_chunk',
+                uuid,
+                start,
+            }));
+            if (signal.aborted)
+                return null;
+            return decodeWorldStateChunk(response, start);
+        },
+    });
     const spawnEntity = (transform) => {
         if (entities.has(transform.uuidString)) {
             return;
         }
         const entity = drawTransform(world, transform, traits.WorldStateStoreAPI, { removable: false });
         entities.set(transform.uuidString, entity);
+        const parsedMetadata = metadataFromStruct(transform.metadata?.fields);
+        chunkLoader.start(transform.uuidString, entity, parsedMetadata);
         if (isPointCloud(transform.physicalObject?.geometryType))
             invalidate();
     };
@@ -50,28 +125,25 @@ const createWorldState = (client) => {
         const entity = entities.get(transform.uuidString);
         if (!entity)
             return;
+        let metadataDirty = false;
         for (const path of changes) {
             if (typeof path === 'string') {
                 if (path.startsWith('poseInObserverFrame.pose')) {
                     entity.set(traits.Pose, transform.poseInObserverFrame?.pose ?? createPose());
                 }
                 else if (path.startsWith('physicalObject') && transform.physicalObject) {
-                    const { geometryType } = transform.physicalObject;
-                    if (geometryType.case === 'box') {
-                        entity.set(traits.Box, createBox(geometryType.value));
-                    }
-                    else if (geometryType.case === 'capsule') {
-                        entity.set(traits.Capsule, createCapsule(geometryType.value));
-                    }
-                    else if (geometryType.case === 'sphere') {
-                        entity.set(traits.Sphere, createSphere(geometryType.value));
-                    }
-                    else if (geometryType.case === 'mesh') {
-                        entity.set(traits.BufferGeometry, parsePlyInput(geometryType.value.mesh));
-                    }
+                    traits.updateGeometryTrait(entity, transform.physicalObject);
+                }
+                else if (path.startsWith('metadata')) {
+                    metadataDirty = true;
                 }
             }
         }
+        if (metadataDirty) {
+            updateMetadata(entity, metadataFromStruct(transform.metadata?.fields), {
+                pointCloud: isPointCloud(transform.physicalObject?.geometryType),
+            });
+        }
     };
     let initialized = false;
     let flushScheduled = false;
@@ -176,6 +248,7 @@ const createWorldState = (client) => {
         scheduleFlush();
     });
     return () => {
+        chunkLoader.dispose();
         for (const [, entity] of entities) {
             if (world.has(entity)) {
                 entity.destroy();

package/dist/metadata.js

@@ -5,7 +5,8 @@ export const isMetadataField = (key) => {
         key === 'color_format' ||
         key === 'opacities' ||
         key === 'show_axes_helper' ||
-        key === 'invisible');
+        key === 'invisible' ||
+        key === 'chunks');
 };
 /**
  * Extracts typed {@link Metadata} from a proto `Struct` fields map.
@@ -65,6 +66,17 @@ export const metadataFromStruct = (fields = {}) => {
                 }
                 break;
             }
+            case 'chunks': {
+                if (typeof unwrappedValue === 'object' && unwrappedValue !== null) {
+                    const obj = unwrappedValue;
+                    json.chunks = {
+                        chunkSize: typeof obj['chunk_size'] === 'number' ? obj['chunk_size'] : 0,
+                        total: typeof obj['total'] === 'number' ? obj['total'] : 0,
+                        stride: typeof obj['stride'] === 'number' ? obj['stride'] : 0,
+                    };
+                }
+                break;
+            }
         }
     }
     return json;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@viamrobotics/motion-tools",
-  "version": "1.18.1",
+  "version": "1.19.1",
   "description": "Motion visualization with Viam",
   "license": "Apache-2.0",
   "type": "module",
@@ -165,8 +165,8 @@
     "test:draw": "go test ./draw/... -count=1",
     "test": "pnpm test:unit -- --run",
     "test:coverage": "npx vitest run --coverage",
-    "test:e2e": "playwright test",
-    "test:e2e-ui": "playwright test --ui",
+    "test:e2e": "./e2e/setup.sh && playwright test",
+    "test:e2e-ui": "./e2e/setup.sh && playwright test --ui",
     "vet:draw": "go vet ./draw/...",
     "vet:client": "go vet ./client/...",
     "vet": "pnpm vet:draw && pnpm vet:client",