@viamrobotics/motion-tools 1.13.1 → 1.15.0

package/dist/hooks/usePointclouds.svelte.js

@@ -1,16 +1,13 @@
 import { CameraClient } from '@viamrobotics/sdk';
-import { setContext, getContext, untrack } from 'svelte';
 import { createResourceClient, createResourceQuery, useResourceNames, } from '@viamrobotics/svelte-sdk';
-import { parsePcdInWorker } from '../loaders/pcd';
-import { RefreshRates, useMachineSettings } from './useMachineSettings.svelte';
-import { useLogs } from './useLogs.svelte';
+import { getContext, setContext, untrack } from 'svelte';
+import { createBufferGeometry, updateBufferGeometry } from '../attribute';
 import { RefetchRates } from '../components/overlay/RefreshRate.svelte';
 import { traits, useWorld } from '../ecs';
+import { parsePcdInWorker } from '../loaders/pcd';
 import { useEnvironment } from './useEnvironment.svelte';
-import { createBufferGeometry, updateBufferGeometry } from '../attribute';
-const typeSafeObjectFromEntries = (entries) => {
-    return Object.fromEntries(entries);
-};
+import { useLogs } from './useLogs.svelte';
+import { RefreshRates, useMachineSettings } from './useMachineSettings.svelte';
 const key = Symbol('pointcloud-context');
 export const providePointclouds = (partID) => {
     const environment = useEnvironment();
@@ -60,7 +57,6 @@ export const providePointclouds = (partID) => {
         refetchInterval: interval === RefetchRates.MANUAL ? false : interval,
     });
     const queries = $derived(enabledClients.map((client) => [client.current.name, createResourceQuery(client, 'getPointCloud', () => options)]));
-    const queryMap = $derived(typeSafeObjectFromEntries(queries));
     $effect(() => {
         for (const [name, query] of queries) {
             untrack(() => {
@@ -77,39 +73,63 @@ export const providePointclouds = (partID) => {
     });
     const entities = new Map();
     $effect(() => {
+        const currentPartID = partID();
+        const activeQueryKeys = new Set();
         for (const [name, query] of queries) {
-            untrack(() => {
-                $effect(() => {
-                    const { data } = query;
-                    if (!data || data.length === 0)
+            const queryKey = `${currentPartID}:${name}`;
+            activeQueryKeys.add(queryKey);
+            $effect(() => {
+                const { data } = query;
+                let disposed = false;
+                const destroyEntity = () => {
+                    const entity = entities.get(queryKey);
+                    if (entity) {
+                        if (world.has(entity))
+                            entity.destroy();
+                        entities.delete(queryKey);
+                    }
+                };
+                if (!data || data.length === 0) {
+                    destroyEntity();
+                    return () => {
+                        disposed = true;
+                    };
+                }
+                parsePcdInWorker(data)
+                    .then(({ positions, colors }) => {
+                    if (disposed) {
                         return;
-                    parsePcdInWorker(data)
-                        .then(({ positions, colors }) => {
-                        const existing = entities.get(name);
-                        if (existing) {
-                            const geometry = existing.get(traits.BufferGeometry);
-                            if (geometry) {
-                                updateBufferGeometry(geometry, positions, colors);
-                                return;
-                            }
+                    }
+                    const existing = entities.get(queryKey);
+                    if (existing) {
+                        const geometry = existing.get(traits.BufferGeometry);
+                        if (geometry) {
+                            updateBufferGeometry(geometry, positions, colors);
+                            return;
                         }
-                        const geometry = createBufferGeometry(positions, colors);
-                        const entity = world.spawn(traits.Parent(name), traits.Name(`${name} pointcloud`), traits.BufferGeometry(geometry), traits.Points);
-                        entities.set(name, entity);
-                    })
-                        .catch((error) => {
-                        logs.add(error.reason, 'error');
-                    });
+                    }
+                    const geometry = createBufferGeometry(positions, colors);
+                    const entity = world.spawn(traits.Parent(name), traits.Name(`${name} pointcloud`), traits.BufferGeometry(geometry), traits.Points);
+                    entities.set(queryKey, entity);
+                })
+                    .catch((error) => {
+                    if (disposed) {
+                        return;
+                    }
+                    logs.add(error?.reason ?? error?.message ?? 'Failed to parse pointcloud', 'error');
                 });
+                return () => {
+                    disposed = true;
+                };
             });
         }
-        // Clean up old entities
-        for (const [name, entity] of entities) {
-            if (!queryMap[name]?.data) {
+        // clean up queries that disappeared entirely
+        for (const [queryKey, entity] of entities) {
+            if (!activeQueryKeys.has(queryKey)) {
                 if (world.has(entity)) {
                     entity.destroy();
                 }
-                entities.delete(name);
+                entities.delete(queryKey);
             }
         }
     });

package/dist/hooks/usePose.svelte.js

@@ -1,15 +1,15 @@
-import { createRobotQuery, useRobotClient } from '@viamrobotics/svelte-sdk';
-import { usePartID } from './usePartID.svelte';
-import { commonApi, Pose } from '@viamrobotics/sdk';
-import { RefreshRates, useMachineSettings } from './useMachineSettings.svelte';
-import { useEnvironment } from './useEnvironment.svelte';
 import { observe } from '@threlte/core';
+import { commonApi, Pose } from '@viamrobotics/sdk';
+import { createRobotQuery, useRobotClient } from '@viamrobotics/svelte-sdk';
 import { untrack } from 'svelte';
-import { useFrames } from './useFrames.svelte';
 import { RefetchRates } from '../components/overlay/RefreshRate.svelte';
+import { useEnvironment } from './useEnvironment.svelte';
+import { useFrames } from './useFrames.svelte';
 import { useLogs } from './useLogs.svelte';
-import { useResourceByName } from './useResourceByName.svelte';
+import { RefreshRates, useMachineSettings } from './useMachineSettings.svelte';
+import { usePartID } from './usePartID.svelte';
 import { useRefetchPoses } from './useRefetchPoses';
+import { useResourceByName } from './useResourceByName.svelte';
 const originFrameComponentTypes = new Set(['arm', 'gantry', 'gripper', 'base']);
 export const usePose = (name, parent) => {
     const environment = useEnvironment();

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

@@ -1,5 +1,5 @@
-import { Object3D } from 'three';
 import type { Entity } from 'koota';
+import { Object3D } from 'three';
 interface SelectedEntityContext {
     readonly current: Entity | undefined;
     readonly instance: number | undefined;

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

@@ -3,6 +3,7 @@ export declare const WEBLABS_CONTEXT_KEY: unique symbol;
 interface Context {
     load: (experiments: string[]) => void;
     isActive(experiment: string): boolean;
+    toggle(experiment: string): void;
 }
 export declare const createWeblabs: () => Context;
 export declare const provideWeblabs: () => void;

package/dist/hooks/useWeblabs.svelte.js

@@ -37,11 +37,22 @@ export const createWeblabs = () => {
             }
         }
     };
+    const toggle = (experiment) => {
+        const cookieExperiments = new Set(getCookieExperiments());
+        if (activeExperiments.has(experiment)) {
+            activeExperiments.delete(experiment);
+            cookieExperiments.delete(experiment);
+        }
+        else {
+            activeExperiments.add(experiment);
+            cookieExperiments.add(experiment);
+        }
+        addCookie('weblab_experiments', [...cookieExperiments].join(','));
+    };
     return {
         load,
-        isActive: (experiment) => {
-            return activeExperiments.has(experiment);
-        },
+        isActive: (experiment) => activeExperiments.has(experiment),
+        toggle,
     };
 };
 export const provideWeblabs = () => {
@@ -58,6 +69,7 @@ export const useWeblabs = () => {
         return {
             load: () => { },
             isActive: () => false,
+            toggle: () => { },
         };
     }
     return context;

package/dist/hooks/useWorldState.svelte.js

@@ -1,14 +1,17 @@
-import { WorldStateStoreClient, TransformChangeType, } from '@viamrobotics/sdk';
+import { useThrelte } from '@threlte/core';
+import { TransformChangeType, WorldStateStoreClient, } from '@viamrobotics/sdk';
 import { createResourceClient, createResourceQuery, createResourceStream, useResourceNames, } from '@viamrobotics/svelte-sdk';
-import { parseMetadata } from '../WorldObject.svelte';
-import { usePartID } from './usePartID.svelte';
+import { Color } from 'three';
+import { createBufferGeometry } from '../attribute';
+import { asColor, asOpacity, isPerVertexColors, STRIDE } from '../buffer';
 import { traits, useWorld } from '../ecs';
-import { createPose } from '../transform';
-import { useThrelte } from '@threlte/core';
 import { createBox, createCapsule, createSphere } from '../geometry';
-import { parsePlyInput } from '../ply';
 import { parsePcdInWorker } from '../loaders/pcd';
-import { createBufferGeometry } from '../attribute';
+import { parseMetadata } from '../metadata';
+import { parsePlyInput } from '../ply';
+import { createPose } from '../transform';
+import { usePartID } from './usePartID.svelte';
+const colorUtil = new Color();
 export const provideWorldStates = () => {
     const partID = usePartID();
     const resourceNames = useResourceNames(() => partID.current, 'world_state_store');
@@ -40,46 +43,43 @@ const createWorldState = (client) => {
         if (parent && parent !== 'world') {
             entityTraits.push(traits.Parent(parent));
         }
-        if (metadata.color) {
-            entityTraits.push(traits.Color(metadata.color));
-        }
-        if (metadata.colors) {
-            entityTraits.push(traits.VertexColors(metadata.colors));
-        }
         if (transform.physicalObject) {
             if (transform.physicalObject.geometryType.case === 'pointcloud') {
+                const metadataColors = metadata.colors;
                 parsePcdInWorker(new Uint8Array(transform.physicalObject.geometryType.value.pointCloud)).then((pointcloud) => {
-                    // pcds are a special case since they have to be loaded in a worker and the trait will be added to the existing entity
                     const entity = entities.get(transform.uuidString);
                     if (!entity) {
                         console.error('Entity not found to add pointcloud trait to', transform.uuidString);
                         return;
                     }
-                    const geometry = createBufferGeometry(pointcloud.positions, pointcloud.colors);
+                    const numPoints = pointcloud.positions.length / STRIDE.POSITIONS;
+                    const vertexColors = metadataColors && isPerVertexColors(metadataColors, numPoints)
+                        ? metadataColors
+                        : pointcloud.colors;
+                    const geometry = createBufferGeometry(pointcloud.positions, vertexColors);
                     entity.add(traits.BufferGeometry(geometry));
                     entity.add(traits.Points);
+                    if (metadataColors && !isPerVertexColors(metadataColors, numPoints)) {
+                        asColor(metadataColors, colorUtil);
+                        entity.add(traits.Color({ r: colorUtil.r, g: colorUtil.g, b: colorUtil.b }));
+                        if (metadataColors.length % STRIDE.COLORS_RGBA === 0) {
+                            entity.add(traits.Opacity(asOpacity(metadataColors)));
+                        }
+                    }
+                    invalidate();
                 });
             }
             else {
+                if (metadata.colors) {
+                    asColor(metadata.colors, colorUtil);
+                    entityTraits.push(traits.Color({ r: colorUtil.r, g: colorUtil.g, b: colorUtil.b }));
+                    if (metadata.colors.length % STRIDE.COLORS_RGBA === 0) {
+                        entityTraits.push(traits.Opacity(asOpacity(metadata.colors)));
+                    }
+                }
                 entityTraits.push(traits.Geometry(transform.physicalObject));
             }
         }
-        if (metadata.shape === 'line' && metadata.points) {
-            const { points } = metadata;
-            const positions = new Float32Array(points.length * 3);
-            for (let i = 0, j = 0, l = points.length * 3; i < l; i += 3, j += 1) {
-                positions[i + 0] = points[j].x;
-                positions[i + 1] = points[j].y;
-                positions[i + 2] = points[j].z;
-            }
-            entityTraits.push(traits.LinePositions(positions), traits.PointColor(metadata.lineDotColor));
-        }
-        if (metadata.gltf) {
-            entityTraits.push(traits.GLTF({ source: { gltf: metadata.gltf }, animationName: '' }));
-        }
-        if (metadata.shape === 'arrow') {
-            entityTraits.push(traits.Arrow);
-        }
         entityTraits.push(traits.Name(transform.referenceFrame), traits.Pose(pose), traits.ShowAxesHelper, traits.WorldStateStoreAPI);
         const entity = world.spawn(...entityTraits);
         entities.set(transform.uuidString, entity);

package/dist/metadata.d.ts

@@ -0,0 +1,22 @@
+import type { PlainMessage, Struct } from '@viamrobotics/sdk';
+/**
+ * Metadata for a Viam `Transform`.
+ *
+ * Per the API this can be a struct of any data, so we type this version for
+ * fields we use and how we expect them to be defined.
+ */
+export type Metadata = {
+    colors?: Uint8Array<ArrayBuffer>;
+};
+/** Type guard that checks whether a string is a recognised {@link Metadata} field name. */
+export declare const isMetadataKey: (key: string) => key is keyof Metadata;
+/**
+ * Extracts typed {@link Metadata} from a proto `Struct` fields map.
+ *
+ * The `colors` field is expected as a base64-encoded string (the only way to
+ * represent binary data in a `google.protobuf.Value`), which is decoded into
+ * a `Uint8Array`.
+ *
+ * Unknown keys are silently ignored.
+ */
+export declare const parseMetadata: (fields?: PlainMessage<Struct>["fields"]) => Metadata;

package/dist/metadata.js

@@ -0,0 +1,66 @@
+/** Type guard that checks whether a string is a recognised {@link Metadata} field name. */
+export const isMetadataKey = (key) => {
+    return key === 'colors';
+};
+/**
+ * Extracts typed {@link Metadata} from a proto `Struct` fields map.
+ *
+ * The `colors` field is expected as a base64-encoded string (the only way to
+ * represent binary data in a `google.protobuf.Value`), which is decoded into
+ * a `Uint8Array`.
+ *
+ * Unknown keys are silently ignored.
+ */
+export const parseMetadata = (fields = {}) => {
+    const json = {};
+    for (const [k, v] of Object.entries(fields)) {
+        if (!isMetadataKey(k))
+            continue;
+        const unwrappedValue = unwrapValue(v);
+        switch (k) {
+            case 'colors': {
+                if (typeof unwrappedValue === 'string') {
+                    const binary = atob(unwrappedValue);
+                    const colorBytes = new Uint8Array(binary.length);
+                    for (let i = 0; i < binary.length; i++) {
+                        colorBytes[i] = binary.charCodeAt(i);
+                    }
+                    json.colors = colorBytes;
+                }
+                break;
+            }
+        }
+    }
+    return json;
+};
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const unwrapValue = (value) => {
+    if (!value?.kind)
+        return value;
+    switch (value.kind.case) {
+        case 'numberValue':
+        case 'stringValue':
+        case 'boolValue': {
+            return value.kind.value;
+        }
+        case 'structValue': {
+            const result = {};
+            for (const [key, val] of Object.entries(value.kind.value.fields || {})) {
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                result[key] = unwrapValue(val);
+            }
+            return result;
+        }
+        case 'listValue': {
+            return (value.kind.value.values?.map(
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            (v) => unwrapValue(v)) || []);
+        }
+        case 'nullValue': {
+            return null;
+        }
+        default: {
+            return value.kind.value;
+        }
+    }
+};

package/dist/plugins/bvh.svelte.js

@@ -1,6 +1,6 @@
 import { injectPlugin, isInstanceOf } from '@threlte/core';
-import { BatchedMesh, Points, Mesh } from 'three';
-import { acceleratedRaycast, computeBoundsTree, disposeBoundsTree, computeBatchedBoundsTree, disposeBatchedBoundsTree, PointsBVH, SAH, BVHHelper, } from 'three-mesh-bvh';
+import { BatchedMesh, Mesh, Points } from 'three';
+import { acceleratedRaycast, BVHHelper, computeBatchedBoundsTree, computeBoundsTree, disposeBatchedBoundsTree, disposeBoundsTree, PointsBVH, SAH, } from 'three-mesh-bvh';
 export const bvh = (raycaster, options) => {
     const bvhOptions = $derived({
         strategy: SAH,

package/dist/snapshot.d.ts

@@ -1,7 +1,27 @@
-import type { World, Entity } from 'koota';
+import type { Entity, World } from 'koota';
 import type { Snapshot } from './buf/draw/v1/snapshot_pb';
-import { type SceneMetadata } from './buf/draw/v1/scene_pb';
 import type { Settings } from './hooks/useSettings.svelte';
+import { type SceneMetadata } from './buf/draw/v1/scene_pb';
+/**
+ * Merges scene-level metadata (grid, camera, point/line settings) into the
+ * current viewer settings. Millimetre values from the proto are converted
+ * to metres.
+ */
 export declare const applySceneMetadata: (settings: Settings, metadata: SceneMetadata) => Settings;
+/**
+ * Spawns ECS entities for every transform and drawing in a {@link Snapshot}.
+ *
+ * Each transform produces one entity with Name, Pose, Parent, Geometry, and
+ * optional Color/Opacity traits. Each drawing produces one or more entities
+ * depending on the geometry type (arrows, points, line, nurbs, model, or
+ * simple shapes like box/sphere/capsule).
+ *
+ * @returns The spawned entities — pass them to {@link destroyEntities} to
+ *          clean up before loading a new snapshot.
+ */
 export declare const spawnSnapshotEntities: (world: World, snapshot: Snapshot) => Entity[];
+/**
+ * Destroys a list of entities that are still alive in the given world.
+ * Silently skips entities that have already been removed.
+ */
 export declare const destroyEntities: (world: World, entities: Entity[]) => void;

package/dist/snapshot.js

@@ -1,14 +1,20 @@
-import { Vector3, Vector4 } from 'three';
+import { Geometry } from '@viamrobotics/sdk';
+import { Color, Vector3, Vector4 } from 'three';
 import { NURBSCurve } from 'three/addons/curves/NURBSCurve.js';
-import { RenderArmModels } from './buf/draw/v1/scene_pb';
 import {} from './buf/draw/v1/drawing_pb';
+import { RenderArmModels } from './buf/draw/v1/scene_pb';
 import { traits } from './ecs';
-import { Geometry } from '@viamrobotics/sdk';
-import { parseMetadata } from './WorldObject.svelte';
-import { rgbaBytesToFloat32, rgbaToHex } from './color';
-import { asFloat32Array, STRIDE } from './buffer';
+import { parseMetadata } from './metadata';
 import { createBufferGeometry } from './attribute';
+import { asColor, asFloat32Array, asOpacity, isPerVertexColors, STRIDE } from './buffer';
+import { rgbaToHex } from './color';
 const vec3 = new Vector3();
+const colorUtil = new Color();
+/**
+ * Merges scene-level metadata (grid, camera, point/line settings) into the
+ * current viewer settings. Millimetre values from the proto are converted
+ * to metres.
+ */
 export const applySceneMetadata = (settings, metadata) => {
     const next = { ...settings };
     if (metadata.grid !== undefined) {
@@ -46,6 +52,17 @@ export const applySceneMetadata = (settings, metadata) => {
     }
     return next;
 };
+/**
+ * Spawns ECS entities for every transform and drawing in a {@link Snapshot}.
+ *
+ * Each transform produces one entity with Name, Pose, Parent, Geometry, and
+ * optional Color/Opacity traits. Each drawing produces one or more entities
+ * depending on the geometry type (arrows, points, line, nurbs, model, or
+ * simple shapes like box/sphere/capsule).
+ *
+ * @returns The spawned entities — pass them to {@link destroyEntities} to
+ *          clean up before loading a new snapshot.
+ */
 export const spawnSnapshotEntities = (world, snapshot) => {
     const entities = [];
     for (const transform of snapshot.transforms) {
@@ -59,6 +76,10 @@ export const spawnSnapshotEntities = (world, snapshot) => {
     }
     return entities;
 };
+/**
+ * Destroys a list of entities that are still alive in the given world.
+ * Silently skips entities that have already been removed.
+ */
 export const destroyEntities = (world, entities) => {
     for (const entity of entities) {
         if (world.has(entity)) {
@@ -92,12 +113,8 @@ const spawnTransformEntity = (world, transform) => {
     entityTraits.push(traits.Pose(poseInFrame?.pose), traits.Parent(poseInFrame?.referenceFrame));
     if (transform.metadata) {
         const metadata = parseMetadata(transform.metadata.fields);
-        if (metadata.color) {
-            entityTraits.push(traits.Color(metadata.color));
-        }
-        if (metadata.opacity !== undefined) {
-            entityTraits.push(traits.Opacity(metadata.opacity));
-        }
+        if (metadata.colors)
+            addColorTraits(entityTraits, metadata.colors);
     }
     return world.spawn(...entityTraits);
 };
@@ -167,15 +184,6 @@ const spawnEntitiesFromDrawing = (world, drawing) => {
         if (parent && parent !== 'world') {
             entityTraits.push(traits.Parent);
         }
-        if (drawing.metadata?.colors) {
-            const colors = rgbaBytesToFloat32(drawing.metadata.colors);
-            if (colors.length === 4) {
-                entityTraits.push(traits.Color({ r: colors[0], g: colors[1], b: colors[2] }), traits.Opacity(colors[3]));
-            }
-            else {
-                entityTraits.push(traits.VertexColors(colors));
-            }
-        }
         if (drawing.physicalObject?.center) {
             entityTraits.push(traits.Center(drawing.physicalObject.center));
         }
@@ -184,9 +192,20 @@ const spawnEntitiesFromDrawing = (world, drawing) => {
             for (let i = 0, l = positions.length; i < l; i += 1) {
                 positions[i] *= 0.001;
             }
-            entityTraits.push(traits.LinePositions(positions), traits.LineWidth(geometryType.value.lineWidth), traits.PointSize(geometryType.value.pointSize));
-            if (geometryType.value.pointSize) {
-                entityTraits.push(traits.PointSize(geometryType.value.pointSize * 0.001));
+            entityTraits.push(traits.LinePositions(positions), traits.LineWidth(geometryType.value.lineWidth), traits.PointSize((geometryType.value.pointSize ?? 0) * 0.001));
+            // Lines pack exactly 2 colors: [lineColor, pointColor]
+            const colors = drawing.metadata?.colors;
+            if (colors && colors.length >= STRIDE.COLORS_RGB) {
+                const stride = colors.length % STRIDE.COLORS_RGBA === 0 ? STRIDE.COLORS_RGBA : STRIDE.COLORS_RGB;
+                asColor(colors, colorUtil, 0);
+                entityTraits.push(traits.Color({ r: colorUtil.r, g: colorUtil.g, b: colorUtil.b }));
+                if (colors.length >= stride * 2) {
+                    asColor(colors, colorUtil, stride);
+                    entityTraits.push(traits.PointColor({ r: colorUtil.r, g: colorUtil.g, b: colorUtil.b }));
+                    if (stride === STRIDE.COLORS_RGBA) {
+                        entityTraits.push(traits.Opacity(asOpacity(colors, 1, 3)));
+                    }
+                }
             }
         }
         else if (geometryType?.case === 'points') {
@@ -195,8 +214,13 @@ const spawnEntitiesFromDrawing = (world, drawing) => {
                 positions[i] *= 0.001;
             }
             const colors = drawing.metadata?.colors;
-            const geometry = createBufferGeometry(positions, colors);
+            const numPoints = positions.length / STRIDE.POSITIONS;
+            const vertexColors = colors && isPerVertexColors(colors, numPoints) ? colors : undefined;
+            const geometry = createBufferGeometry(positions, vertexColors);
             entityTraits.push(traits.BufferGeometry(geometry));
+            if (colors && !vertexColors) {
+                addColorTraits(entityTraits, colors);
+            }
             if (geometryType.value.pointSize) {
                 entityTraits.push(traits.PointSize(geometryType.value.pointSize * 0.001));
             }
@@ -227,9 +251,27 @@ const spawnEntitiesFromDrawing = (world, drawing) => {
                 points[i + 2] = vec3.z;
             }
             entityTraits.push(traits.LinePositions(points));
+            const colors = drawing.metadata?.colors;
+            if (colors) {
+                addColorTraits(entityTraits, colors);
+            }
+        }
+        else {
+            // Box, sphere, capsule, and other geometry shapes with a single color
+            const colors = drawing.metadata?.colors;
+            if (colors) {
+                addColorTraits(entityTraits, colors);
+            }
         }
         const entity = world.spawn(...entityTraits, traits.SnapshotAPI, traits.Removable);
         entities.push(entity);
     }
     return entities;
 };
+const addColorTraits = (entityTraits, bytes) => {
+    asColor(bytes, colorUtil);
+    entityTraits.push(traits.Color(colorUtil));
+    const isRgba = bytes.length % STRIDE.COLORS_RGBA === 0;
+    if (isRgba)
+        entityTraits.push(traits.Opacity(asOpacity(bytes)));
+};

package/dist/three/BatchedArrow.d.ts

@@ -1,5 +1,5 @@
-import { BatchedMesh, Vector3, Color } from 'three';
 import type { OBB } from 'three/addons/math/OBB.js';
+import { BatchedMesh, Color, Vector3 } from 'three';
 export declare class BatchedArrow {
     mesh: BatchedMesh;
     _geometryId: number;

package/dist/three/BatchedArrow.js

@@ -1,4 +1,4 @@
-import { BatchedMesh, MeshBasicMaterial, Object3D, Vector3, Color, Box3 } from 'three';
+import { BatchedMesh, Box3, Color, MeshBasicMaterial, Object3D, Vector3 } from 'three';
 import { createArrowGeometry } from './arrow';
 const black = new Color('black');
 const axis = new Vector3();

package/dist/three/InstancedArrows/InstancedArrows.d.ts

@@ -1,4 +1,4 @@
-import { Group, Mesh, BufferGeometry, InstancedInterleavedBuffer, type ColorRepresentation, Vector3, Box3 } from 'three';
+import { Box3, BufferGeometry, type ColorRepresentation, Group, InstancedInterleavedBuffer, Mesh, Vector3 } from 'three';
 export declare class InstancedArrows extends Group {
     isInstancedArrows: boolean;
     count: number;

package/dist/three/InstancedArrows/InstancedArrows.js

@@ -1,8 +1,8 @@
-import { RawShaderMaterial, FrontSide, Group, InstancedBufferAttribute, DynamicDrawUsage, Mesh, BufferGeometry, InstancedInterleavedBuffer, InterleavedBufferAttribute, Material, Color, Vector3, Box3, } from 'three';
-import vertexShader from './vertex.glsl';
+import { Box3, BufferGeometry, Color, DynamicDrawUsage, FrontSide, Group, InstancedBufferAttribute, InstancedInterleavedBuffer, InterleavedBufferAttribute, Material, Mesh, RawShaderMaterial, Vector3, } from 'three';
+import { computeBoundingBox } from './box';
 import fragmentShader from './fragment.glsl';
 import { createHeadGeometry, createShaftGeometry, toInstanced } from './geometry';
-import { computeBoundingBox } from './box';
+import vertexShader from './vertex.glsl';
 const defaults = {
     LENGTH: 0.1,
     HEAD_LENGTH: 0.02,

package/dist/three/InstancedArrows/box.js

@@ -1,4 +1,4 @@
-import { RawShaderMaterial, Box3, BufferGeometry } from 'three';
+import { Box3, BufferGeometry, RawShaderMaterial } from 'three';
 const bounds = new Box3();
 export function computeBoundingBox(geometry) {
     const src = this.poses.array;

package/dist/three/InstancedArrows/geometry.js

@@ -1,4 +1,4 @@
-import { BufferGeometry, BufferAttribute, InstancedBufferGeometry } from 'three';
+import { BufferAttribute, BufferGeometry, InstancedBufferGeometry } from 'three';
 export const createShaftGeometry = () => {
     // Triangular prism aligned to +Y, base at y=0, top at y=1.
     // No caps, 6 verts, 6 side triangles.

package/dist/three/InstancedArrows/raycast.d.ts

@@ -1,4 +1,4 @@
-import { Raycaster, type Intersection } from 'three';
+import { type Intersection, Raycaster } from 'three';
 import type { InstancedArrows } from './InstancedArrows';
 export declare function meshBoundsRaycast(this: InstancedArrows, raycaster: Raycaster, intersects: Intersection[]): void;
 /**

package/dist/three/InstancedArrows/raycast.js

@@ -1,4 +1,4 @@
-import { Ray, Matrix4, Raycaster, Vector3, Box3, RawShaderMaterial } from 'three';
+import { Box3, Matrix4, RawShaderMaterial, Ray, Raycaster, Vector3 } from 'three';
 const vec3 = new Vector3();
 const inverseMatrix = new Matrix4();
 const localRay = new Ray();

package/dist/three/OBBHelper.d.ts

@@ -1,5 +1,6 @@
-import { LineSegments, Vector3, Object3D } from 'three';
-export declare class OBBHelper extends LineSegments {
+import { Object3D, Vector3 } from 'three';
+import { LineSegments2 } from 'three/examples/jsm/lines/LineSegments2.js';
+export declare class OBBHelper extends LineSegments2 {
     constructor(color?: number, linewidth?: number);
     setFromOBB(obb: {
         center: Vector3;