@viamrobotics/motion-tools 0.1.0

package/dist/three/AxesHelper.d.ts

@@ -0,0 +1,5 @@
+import { Mesh } from 'three';
+export declare class AxesHelper extends Mesh {
+    constructor(size?: number, thickness?: number);
+    dispose(): void;
+}

package/dist/three/AxesHelper.js

@@ -0,0 +1,35 @@
+import { Mesh, Vector3, Color, BoxGeometry, BufferAttribute, MeshBasicMaterial } from 'three';
+import { mergeGeometries } from 'three/addons/utils/BufferGeometryUtils.js';
+export class AxesHelper extends Mesh {
+    constructor(size = 0.1, thickness = 0.005) {
+        const axisGeometries = [];
+        const axes = [
+            { dir: new Vector3(1, 0, 0), color: new Color(0xff0000) }, // X - Red
+            { dir: new Vector3(0, 1, 0), color: new Color(0x00ff00) }, // Y - Green
+            { dir: new Vector3(0, 0, 1), color: new Color(0x0000ff) }, // Z - Blue
+        ];
+        const dimensions = new Vector3();
+        for (const axis of axes) {
+            dimensions.set(axis.dir.x ? size : thickness, axis.dir.y ? size : thickness, axis.dir.z ? size : thickness);
+            const geometry = new BoxGeometry(dimensions.x, dimensions.y, dimensions.z);
+            // Translate so it starts at the origin (like traditional AxesHelper)
+            geometry.translate(dimensions.x / 2, dimensions.y / 2, dimensions.z / 2);
+            // Add vertex colors
+            const { count } = geometry.attributes.position;
+            const colorArray = new Float32Array(count * 3);
+            for (let i = 0; i < count; i++) {
+                colorArray[i * 3 + 0] = axis.color.r;
+                colorArray[i * 3 + 1] = axis.color.g;
+                colorArray[i * 3 + 2] = axis.color.b;
+            }
+            geometry.setAttribute('color', new BufferAttribute(colorArray, 3));
+            axisGeometries.push(geometry);
+        }
+        const mergedGeometry = mergeGeometries(axisGeometries);
+        const material = new MeshBasicMaterial({ vertexColors: true });
+        super(mergedGeometry, material);
+    }
+    dispose() {
+        this.geometry.dispose();
+    }
+}

package/dist/three/BatchedArrow.d.ts

@@ -0,0 +1,30 @@
+import { BatchedMesh, MeshBasicMaterial, Object3D, Vector3, Box3, Matrix4 } from 'three';
+interface Arrow {
+    shaftId: number;
+    headId: number;
+}
+export declare class BatchedArrow {
+    batchedMesh: BatchedMesh;
+    shaftGeoId: number;
+    coneGeoId: number;
+    shaftWidth: number;
+    _arrows: Map<number, Arrow>;
+    _idToArrowId: Map<number, number>;
+    _pool: Arrow[];
+    _idCounter: number;
+    constructor({ maxArrows, shaftWidth, material, }?: {
+        maxArrows?: number | undefined;
+        shaftWidth?: number | undefined;
+        material?: MeshBasicMaterial | undefined;
+    });
+    addArrow(dir: Vector3, origin: Vector3, length?: number, color?: string): number;
+    getArrowId(instanceId: number): number | undefined;
+    getBoundingBoxAt(arrowId: number, target: Box3): Box3 | undefined;
+    removeArrow(arrowId: number): void;
+    clear(): void;
+    getObject3d(id: number): Object3D<import("three").Object3DEventMap>;
+    _computeTransform(origin: Vector3, dir: Vector3, lengthY: number, scaleXZ?: number): Matrix4;
+    _quaternionFromDirection(dir: Vector3): import("three").Quaternion;
+    get object3d(): BatchedMesh;
+}
+export {};

package/dist/three/BatchedArrow.js

@@ -0,0 +1,126 @@
+import { BatchedMesh, BoxGeometry, ConeGeometry, MeshBasicMaterial, Object3D, Vector3, Color, Box3, Matrix4, } from 'three';
+const axis = new Vector3();
+const object3d = new Object3D();
+const vec3 = new Vector3();
+const box1 = new Box3();
+const box2 = new Box3();
+const mat4_1 = new Matrix4();
+const mat4_2 = new Matrix4();
+let index = 0;
+export class BatchedArrow {
+    batchedMesh;
+    shaftGeoId = -1;
+    coneGeoId = -1;
+    shaftWidth = 0;
+    _arrows = new Map(); // arrowId -> { shaftId, headId }
+    _idToArrowId = new Map();
+    _pool = [];
+    _idCounter = 0;
+    constructor({ maxArrows = 20_000, shaftWidth = 0.001, material = new MeshBasicMaterial({ color: 0xffff00, toneMapped: false }), } = {}) {
+        const shaftGeo = new BoxGeometry(1, 1, 1);
+        shaftGeo.translate(0, 0.5, 0);
+        const coneGeo = new ConeGeometry(0.5, 1, 5, 1);
+        coneGeo.translate(0, -0.5, 0);
+        const shaftVertexCount = shaftGeo.getAttribute('position').count;
+        const coneVertexCount = coneGeo.getAttribute('position').count;
+        const shaftIndexCount = shaftGeo.index?.count ?? shaftVertexCount;
+        const coneIndexCount = coneGeo.index?.count ?? coneVertexCount;
+        const maxVertexCount = maxArrows * (shaftVertexCount + coneVertexCount);
+        const maxIndexCount = maxArrows * (shaftIndexCount + coneIndexCount);
+        this.batchedMesh = new BatchedMesh(maxArrows * 2, maxVertexCount, maxIndexCount, material);
+        this.batchedMesh.name = `batched arrows ${++index}`;
+        this.batchedMesh.frustumCulled = false;
+        this.shaftWidth = shaftWidth;
+        this.shaftGeoId = this.batchedMesh.addGeometry(shaftGeo);
+        this.coneGeoId = this.batchedMesh.addGeometry(coneGeo);
+    }
+    addArrow(dir, origin, length = 0.1, color) {
+        dir.normalize();
+        const headLength = length * 0.2;
+        const headWidth = headLength * 0.2;
+        let shaftId;
+        let headId;
+        const instance = this._pool.pop();
+        if (instance) {
+            ;
+            ({ shaftId, headId } = instance);
+        }
+        else {
+            shaftId = this.batchedMesh.addInstance(this.shaftGeoId);
+            headId = this.batchedMesh.addInstance(this.coneGeoId);
+        }
+        // Apply shaft transform
+        const shaftMatrix = this._computeTransform(origin, dir, length - headLength, this.shaftWidth);
+        this.batchedMesh.setMatrixAt(shaftId, shaftMatrix);
+        // Compute cone position = origin + dir * length
+        const coneOrigin = vec3.copy(dir).multiplyScalar(length).add(origin);
+        const coneMatrix = this._computeTransform(coneOrigin, dir, headLength, headWidth * 4);
+        this.batchedMesh.setMatrixAt(headId, coneMatrix);
+        if (color) {
+            const col = new Color(color);
+            this.batchedMesh.setColorAt(shaftId, col);
+            this.batchedMesh.setColorAt(headId, col);
+        }
+        this.batchedMesh.setVisibleAt(shaftId, true);
+        this.batchedMesh.setVisibleAt(headId, true);
+        const arrowId = this._idCounter++;
+        this._arrows.set(arrowId, { shaftId, headId });
+        this._idToArrowId.set(shaftId, arrowId);
+        this._idToArrowId.set(headId, arrowId);
+        return arrowId;
+    }
+    getArrowId(instanceId) {
+        return this._idToArrowId.get(instanceId);
+    }
+    getBoundingBoxAt(arrowId, target) {
+        const arrow = this._arrows.get(arrowId);
+        if (arrow) {
+            const headBox = this.batchedMesh.getBoundingBoxAt(this.coneGeoId, box1);
+            const tailBox = this.batchedMesh.getBoundingBoxAt(this.shaftGeoId, box2);
+            if (headBox && tailBox) {
+                this.batchedMesh.getMatrixAt(arrow.headId, mat4_1);
+                this.batchedMesh.getMatrixAt(arrow.shaftId, mat4_2);
+                target.copy(headBox.applyMatrix4(mat4_1)).union(tailBox.applyMatrix4(mat4_2));
+                return target;
+            }
+        }
+    }
+    removeArrow(arrowId) {
+        const arrow = this._arrows.get(arrowId);
+        if (!arrow)
+            return;
+        this.batchedMesh.setVisibleAt(arrow.shaftId, false);
+        this.batchedMesh.setVisibleAt(arrow.headId, false);
+        this._pool.push(arrow);
+        this._arrows.delete(arrowId);
+    }
+    clear() {
+        for (const id of this._arrows.keys()) {
+            this.removeArrow(id);
+        }
+    }
+    getObject3d(id) {
+        this.batchedMesh.getMatrixAt(id, object3d.matrix);
+        object3d.updateMatrix();
+        return object3d;
+    }
+    _computeTransform(origin, dir, lengthY, scaleXZ = 1) {
+        object3d.position.copy(origin);
+        object3d.quaternion.copy(this._quaternionFromDirection(dir));
+        object3d.scale.set(scaleXZ, lengthY, scaleXZ);
+        object3d.updateMatrix();
+        return object3d.matrix.clone();
+    }
+    _quaternionFromDirection(dir) {
+        if (dir.y > 0.99999)
+            return object3d.quaternion.set(0, 0, 0, 1);
+        if (dir.y < -0.99999)
+            return object3d.quaternion.set(1, 0, 0, 0);
+        axis.set(dir.z, 0, -dir.x).normalize();
+        const radians = Math.acos(dir.y);
+        return object3d.quaternion.setFromAxisAngle(axis, radians);
+    }
+    get object3d() {
+        return this.batchedMesh;
+    }
+}

package/dist/three/BoxHelper.d.ts

@@ -0,0 +1,50 @@
+import { Box3, LineSegments, Object3D } from 'three';
+/**
+ * Helper object to graphically show the world-axis-aligned bounding box
+ * around an object. The actual bounding box is handled with {@link Box3},
+ * this is just a visual helper for debugging. It can be automatically
+ * resized with {@link BoxHelper#update} when the object it's created from
+ * is transformed. Note that the object must have a geometry for this to work,
+ * so it won't work with sprites.
+ *
+ * ```js
+ * const sphere = new THREE.SphereGeometry();
+ * const object = new THREE.Mesh( sphere, new THREE.MeshBasicMaterial( 0xff0000 ) );
+ * const box = new THREE.BoxHelper( object, 0xffff00 );
+ * scene.add( box );
+ * ```
+ *
+ * @augments LineSegments
+ */
+declare class BoxHelper extends LineSegments {
+    type: string;
+    matrixAutoUpdate: boolean;
+    object: Object3D | undefined;
+    /**
+     * Constructs a new box helper.
+     *
+     * @param {Object3D} [object] - The 3D object to show the world-axis-aligned bounding box.
+     * @param {number|Color|string} [color=0xffff00] - The box's color.
+     */
+    constructor(object: Object3D, color?: number);
+    /**
+     * Updates the helper's geometry to match the dimensions of the object,
+     * including any children.
+     */
+    update(): void;
+    /**
+     * Updates the wireframe box for the passed object.
+     *
+     * @param {Object3D} object - The 3D object to create the helper for.
+     * @return {BoxHelper} A reference to this instance.
+     */
+    setFromObject(object: Object3D): this;
+    setFromBox3(box: Box3): this;
+    copy(source: BoxHelper, recursive: boolean): this;
+    /**
+     * Frees the GPU-related resources allocated by this instance. Call this
+     * method whenever this instance is no longer used in your app.
+     */
+    dispose(): void;
+}
+export { BoxHelper };

package/dist/three/BoxHelper.js

@@ -0,0 +1,134 @@
+import { Box3, LineSegments, LineBasicMaterial, BufferAttribute, BufferGeometry, Object3D, Material, } from 'three';
+const _box = /*@__PURE__*/ new Box3();
+/**
+ * Helper object to graphically show the world-axis-aligned bounding box
+ * around an object. The actual bounding box is handled with {@link Box3},
+ * this is just a visual helper for debugging. It can be automatically
+ * resized with {@link BoxHelper#update} when the object it's created from
+ * is transformed. Note that the object must have a geometry for this to work,
+ * so it won't work with sprites.
+ *
+ * ```js
+ * const sphere = new THREE.SphereGeometry();
+ * const object = new THREE.Mesh( sphere, new THREE.MeshBasicMaterial( 0xff0000 ) );
+ * const box = new THREE.BoxHelper( object, 0xffff00 );
+ * scene.add( box );
+ * ```
+ *
+ * @augments LineSegments
+ */
+class BoxHelper extends LineSegments {
+    type = 'BoxHelper';
+    matrixAutoUpdate = false;
+    object;
+    /**
+     * Constructs a new box helper.
+     *
+     * @param {Object3D} [object] - The 3D object to show the world-axis-aligned bounding box.
+     * @param {number|Color|string} [color=0xffff00] - The box's color.
+     */
+    constructor(object, color = 0xffff00) {
+        const indices = new Uint16Array([
+            0, 1, 1, 2, 2, 3, 3, 0, 4, 5, 5, 6, 6, 7, 7, 4, 0, 4, 1, 5, 2, 6, 3, 7,
+        ]);
+        const positions = new Float32Array(8 * 3);
+        const geometry = new BufferGeometry();
+        geometry.setIndex(new BufferAttribute(indices, 1));
+        geometry.setAttribute('position', new BufferAttribute(positions, 3));
+        super(geometry, new LineBasicMaterial({ color: color, toneMapped: false }));
+        /**
+         * The 3D object being visualized.
+         *
+         * @type {Object3D}
+         */
+        this.object = object;
+        this.update();
+    }
+    /**
+     * Updates the helper's geometry to match the dimensions of the object,
+     * including any children.
+     */
+    update() {
+        if (this.object !== undefined) {
+            _box.setFromObject(this.object);
+        }
+        if (_box.isEmpty())
+            return;
+        const min = _box.min;
+        const max = _box.max;
+        /*
+            5____4
+        1/___0/|
+        | 6__|_7
+        2/___3/
+
+        0: max.x, max.y, max.z
+        1: min.x, max.y, max.z
+        2: min.x, min.y, max.z
+        3: max.x, min.y, max.z
+        4: max.x, max.y, min.z
+        5: min.x, max.y, min.z
+        6: min.x, min.y, min.z
+        7: max.x, min.y, min.z
+        */
+        const position = this.geometry.attributes.position;
+        const array = position.array;
+        array[0] = max.x;
+        array[1] = max.y;
+        array[2] = max.z;
+        array[3] = min.x;
+        array[4] = max.y;
+        array[5] = max.z;
+        array[6] = min.x;
+        array[7] = min.y;
+        array[8] = max.z;
+        array[9] = max.x;
+        array[10] = min.y;
+        array[11] = max.z;
+        array[12] = max.x;
+        array[13] = max.y;
+        array[14] = min.z;
+        array[15] = min.x;
+        array[16] = max.y;
+        array[17] = min.z;
+        array[18] = min.x;
+        array[19] = min.y;
+        array[20] = min.z;
+        array[21] = max.x;
+        array[22] = min.y;
+        array[23] = min.z;
+        position.needsUpdate = true;
+        this.geometry.computeBoundingSphere();
+    }
+    /**
+     * Updates the wireframe box for the passed object.
+     *
+     * @param {Object3D} object - The 3D object to create the helper for.
+     * @return {BoxHelper} A reference to this instance.
+     */
+    setFromObject(object) {
+        this.object = object;
+        this.update();
+        return this;
+    }
+    setFromBox3(box) {
+        this.object = undefined;
+        _box.copy(box);
+        this.update();
+        return this;
+    }
+    copy(source, recursive) {
+        super.copy(source, recursive);
+        this.object = source.object;
+        return this;
+    }
+    /**
+     * Frees the GPU-related resources allocated by this instance. Call this
+     * method whenever this instance is no longer used in your app.
+     */
+    dispose() {
+        this.geometry.dispose();
+        this.material.dispose();
+    }
+}
+export { BoxHelper };

package/dist/three/CapsuleGeometry.d.ts

@@ -0,0 +1,10 @@
+import { LatheGeometry } from 'three';
+/**
+ * An alternate definition of a THREE.CapsuleGeometry: the length
+ * represents the entire length of the capsule, including the rounded ends,
+ * rather than just the midsection, which is the default THREE.CapsuleGeometry definition.
+ */
+export declare class CapsuleGeometry extends LatheGeometry {
+    type: string;
+    constructor(radius?: number, length?: number, capSegments?: number, radialSegments?: number);
+}

package/dist/three/CapsuleGeometry.js

@@ -0,0 +1,17 @@
+import { LatheGeometry, Path } from 'three';
+/**
+ * An alternate definition of a THREE.CapsuleGeometry: the length
+ * represents the entire length of the capsule, including the rounded ends,
+ * rather than just the midsection, which is the default THREE.CapsuleGeometry definition.
+ */
+export class CapsuleGeometry extends LatheGeometry {
+    type = 'CapsuleGeometry';
+    constructor(radius = 1, length = 1, capSegments = 4, radialSegments = 8) {
+        const path = new Path();
+        const midsectionLength = length - 2 * radius;
+        path.absarc(0, -midsectionLength / 2, radius, Math.PI * 1.5, 0);
+        path.absarc(0, midsectionLength / 2, radius, 0, Math.PI * 0.5);
+        super(path.getPoints(capSegments), radialSegments);
+        this.rotateX(-Math.PI / 2);
+    }
+}

package/dist/transform.d.ts

@@ -0,0 +1,11 @@
+import type { Geometry, Pose } from '@viamrobotics/sdk';
+import { type Object3D, Quaternion, Vector3 } from 'three';
+export declare const createPose: (pose?: Pose) => Pose;
+export declare const createGeometry: (geometryType?: Geometry["geometryType"], label?: string) => Geometry;
+export declare const quaternionToPose: (quaternion: Quaternion, pose: Partial<Pose>) => void;
+export declare const vector3ToPose: (vec3: Vector3, pose: Partial<Pose>) => void;
+export declare const object3dToPose: (object3d: Object3D, pose: Partial<Pose>) => Partial<import("@viamrobotics/sdk").PlainMessage<import("@viamrobotics/sdk/dist/gen/common/v1/common_pb").Pose>>;
+export declare const poseToQuaternion: (pose: Partial<Pose>, quaternion: Quaternion) => void;
+export declare const poseToVector3: (pose: Partial<Pose>, vec3: Vector3) => void;
+export declare const poseToObject3d: (pose: Partial<Pose>, object3d: Object3D) => void;
+export declare const scaleToDimensions: (scale: Vector3, geometry: Geometry["geometryType"]) => void;

package/dist/transform.js

@@ -0,0 +1,65 @@
+import { OrientationVector } from '@viamrobotics/three';
+import { MathUtils, Quaternion, Vector3 } from 'three';
+const ov = new OrientationVector();
+export const createPose = (pose) => {
+    return {
+        x: pose?.x ?? 0,
+        y: pose?.y ?? 0,
+        z: pose?.z ?? 0,
+        oX: pose?.oX ?? 0,
+        oY: pose?.oY ?? 0,
+        oZ: pose?.oZ ?? 1,
+        theta: pose?.theta ?? 0,
+    };
+};
+export const createGeometry = (geometryType, label = '') => {
+    return {
+        center: createPose(),
+        label,
+        geometryType: geometryType ?? { case: undefined, value: undefined },
+    };
+};
+export const quaternionToPose = (quaternion, pose) => {
+    ov.setFromQuaternion(quaternion);
+    pose.oX = ov.x;
+    pose.oY = ov.y;
+    pose.oZ = ov.z;
+    pose.theta = MathUtils.radToDeg(ov.th);
+};
+export const vector3ToPose = (vec3, pose) => {
+    pose.x = vec3.x * 1000;
+    pose.y = vec3.y * 1000;
+    pose.z = vec3.z * 1000;
+};
+export const object3dToPose = (object3d, pose) => {
+    vector3ToPose(object3d.position, pose);
+    quaternionToPose(object3d.quaternion, pose);
+    return pose;
+};
+export const poseToQuaternion = (pose, quaternion) => {
+    const th = MathUtils.degToRad(pose.theta ?? 0);
+    ov.set(pose.oX, pose.oY, pose.oZ, th);
+    ov.toQuaternion(quaternion);
+};
+export const poseToVector3 = (pose, vec3) => {
+    vec3.set(pose.x ?? 0, pose.y ?? 0, pose.z ?? 0).multiplyScalar(0.001);
+};
+export const poseToObject3d = (pose, object3d) => {
+    poseToVector3(pose, object3d.position);
+    poseToQuaternion(pose, object3d.quaternion);
+};
+export const scaleToDimensions = (scale, geometry) => {
+    if (geometry.case === 'box') {
+        geometry.value.dimsMm ??= { x: 0, y: 0, z: 0 };
+        geometry.value.dimsMm.x *= scale.x;
+        geometry.value.dimsMm.y *= scale.y;
+        geometry.value.dimsMm.z *= scale.z;
+    }
+    else if (geometry.case === 'capsule') {
+        geometry.value.radiusMm *= scale.x;
+        geometry.value.lengthMm *= scale.y;
+    }
+    else if (geometry.case === 'sphere') {
+        geometry.value.radiusMm *= scale.x;
+    }
+};

package/package.json

@@ -0,0 +1,110 @@
+{
+  "name": "@viamrobotics/motion-tools",
+  "version": "0.1.0",
+  "description": "Motion visualization with Viam",
+  "license": "Apache-2.0",
+  "type": "module",
+  "devDependencies": {
+    "@ag-grid-community/client-side-row-model": "^32.3.5",
+    "@ag-grid-community/core": "^32.3.5",
+    "@ag-grid-community/styles": "^32.3.5",
+    "@changesets/cli": "^2.29.4",
+    "@dimforge/rapier3d-compat": "^0.17.0",
+    "@eslint/compat": "^1.2.9",
+    "@eslint/js": "^9.27.0",
+    "@playwright/test": "^1.52.0",
+    "@skeletonlabs/skeleton": "3.1.3",
+    "@skeletonlabs/skeleton-svelte": "1.2.2",
+    "@sveltejs/adapter-static": "^3.0.8",
+    "@sveltejs/kit": "^2.21.1",
+    "@sveltejs/package": "^2.3.11",
+    "@sveltejs/vite-plugin-svelte": "^5.0.3",
+    "@tailwindcss/forms": "^0.5.10",
+    "@tailwindcss/vite": "^4.1.7",
+    "@tanstack/svelte-query": "^5.76.2",
+    "@tanstack/svelte-query-devtools": "^5.76.2",
+    "@testing-library/jest-dom": "^6.6.3",
+    "@testing-library/svelte": "^5.2.8",
+    "@threlte/core": "^8.0.4",
+    "@threlte/extras": "^9.2.1",
+    "@threlte/rapier": "^3.1.4",
+    "@threlte/xr": "^1.0.5",
+    "@types/bun": "^1.2.14",
+    "@types/lodash-es": "^4.17.12",
+    "@types/three": "^0.176.0",
+    "@typescript-eslint/eslint-plugin": "^8.32.1",
+    "@typescript-eslint/parser": "^8.32.1",
+    "@viamrobotics/prime-core": "^0.1.5",
+    "@viamrobotics/sdk": "0.42.0",
+    "@viamrobotics/svelte-sdk": "0.1.4",
+    "@viamrobotics/three": "^0.0.9",
+    "@vitejs/plugin-basic-ssl": "^2.0.0",
+    "@zag-js/svelte": "1.12.4",
+    "@zag-js/tree-view": "1.12.4",
+    "camera-controls": "^2.10.1",
+    "eslint": "^9.27.0",
+    "eslint-config-prettier": "^10.1.5",
+    "eslint-plugin-svelte": "^3.9.0",
+    "globals": "^16.1.0",
+    "idb-keyval": "^6.2.2",
+    "jsdom": "^26.1.0",
+    "lodash-es": "^4.17.21",
+    "lucide-svelte": "^0.511.0",
+    "prettier": "^3.5.3",
+    "prettier-plugin-svelte": "^3.4.0",
+    "prettier-plugin-tailwindcss": "^0.6.11",
+    "publint": "^0.3.12",
+    "runed": "^0.28.0",
+    "svelte": "5.33.0",
+    "svelte-check": "^4.2.1",
+    "svelte-virtuallists": "^1.4.2",
+    "tailwindcss": "^4.1.7",
+    "three": "^0.176.0",
+    "threlte-uikit": "^1.0.0",
+    "tsx": "^4.19.4",
+    "typescript": "^5.8.3",
+    "typescript-eslint": "^8.32.1",
+    "vite": "^6.3.5",
+    "vite-plugin-mkcert": "^1.17.8",
+    "vitest": "^3.1.4"
+  },
+  "peerDependencies": {
+    "@tanstack/svelte-query": ">=5",
+    "@viamrobotics/sdk": ">=0.38",
+    "@viamrobotics/svelte-sdk": ">=0.1",
+    "svelte": ">=5"
+  },
+  "packageManager": "pnpm@8.15.6+sha256.01c01eeb990e379b31ef19c03e9d06a14afa5250b82e81303f88721c99ff2e6f",
+  "svelte": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "svelte": "./dist/index.js"
+    }
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/viam-labs/motion-tools.git"
+  },
+  "files": [
+    "dist",
+    "!dist/**/*.test.*",
+    "!dist/**/*.spec.*"
+  ],
+  "scripts": {
+    "dev": "tsx server/check-bun && bun run server/server.ts",
+    "build": "vite build && npm run prepack",
+    "preview": "vite preview",
+    "check": "svelte-kit sync && svelte-check --tsconfig ./tsconfig.json",
+    "check:watch": "svelte-kit sync && svelte-check --tsconfig ./tsconfig.json --watch",
+    "format": "prettier --write .",
+    "lint": "prettier --check . && eslint .",
+    "test:unit": "vitest",
+    "test:client": "go test ./... -count=1",
+    "test": "pnpm test:unit -- --run",
+    "test:e2e": "playwright test",
+    "model-pipeline:run": "node scripts/model-pipeline.js",
+    "release": "changeset publish"
+  }
+}