@wandelbots/nova-js 3.2.0-pr.dev-e2e-jogging-test.143.4f02caf → 3.2.0-pr.feat-v2.155.e91b019

package/dist/lib/v2/index.js

@@ -1,11 +1,242 @@
-import { AutoReconnectingWebsocket, availableStorage, loginWithAuth0 } from "../../LoginWithAuth0-0g0wWRUC.js";
+import { AutoReconnectingWebsocket, XYZ_TO_VECTOR, availableStorage, loginWithAuth0, tryParseJson } from "../../LoginWithAuth0-CaX7yo7d.js";
 import axios, { AxiosError, isAxiosError } from "axios";
+import { makeAutoObservable, runInAction, when } from "mobx";
+import * as THREE from "three";
+import { Vector3 } from "three";
+import { Vector3 as Vector3$1 } from "three/src/math/Vector3.js";
 import urlJoin from "url-join";
 import * as pathToRegexp from "path-to-regexp";
 import { ApplicationApi, BUSInputsOutputsApi, CellApi, ControllerApi, ControllerInputsOutputsApi, JoggingApi, KinematicsApi, MotionGroupApi, MotionGroupModelsApi, StoreCollisionComponentsApi, StoreCollisionSetupsApi, StoreObjectApi, SystemApi, TrajectoryCachingApi, TrajectoryExecutionApi, TrajectoryPlanningApi, VirtualControllerApi, VirtualControllerBehaviorApi, VirtualControllerInputsOutputsApi } from "@wandelbots/nova-api/v2";
 
 export * from "@wandelbots/nova-api/v2"
 
+//#region src/lib/v2/motionStateUpdate.ts
+function jointValuesEqual(oldJointValues, newJointValues, changeDeltaThreshold) {
+	if (newJointValues.length !== oldJointValues.length) return true;
+	for (let jointIndex = 0; jointIndex < newJointValues.length; jointIndex++) if (Math.abs(newJointValues[jointIndex] - oldJointValues[jointIndex]) > changeDeltaThreshold) return false;
+	return true;
+}
+function poseEqual(oldTcp, newTcp, changeDeltaThreshold) {
+	if (oldTcp === void 0 && newTcp || oldTcp && newTcp === void 0) return false;
+	if (oldTcp?.orientation === void 0 || newTcp?.orientation === void 0 || oldTcp?.position === void 0 || newTcp?.position === void 0) return false;
+	if (oldTcp === void 0 || newTcp === void 0) return true;
+	let changedDelta = 0;
+	changedDelta += Math.abs(oldTcp.orientation[0] - newTcp.orientation[0]);
+	changedDelta += Math.abs(oldTcp.orientation[1] - newTcp.orientation[1]);
+	changedDelta += Math.abs(oldTcp.orientation[2] - newTcp.orientation[2]);
+	changedDelta += Math.abs(oldTcp.position[0] - newTcp.position[0]);
+	changedDelta += Math.abs(oldTcp.position[1] - newTcp.position[1]);
+	changedDelta += Math.abs(oldTcp.position[2] - newTcp.position[2]);
+	return changedDelta <= changeDeltaThreshold;
+}
+function tcpMotionEqual(oldMotionState, newMotionState, changeDeltaThreshold) {
+	return oldMotionState.coordinate_system === newMotionState.coordinate_system && oldMotionState.tcp === newMotionState.tcp && poseEqual(oldMotionState.tcp_pose, newMotionState.tcp_pose, changeDeltaThreshold);
+}
+
+//#endregion
+//#region src/lib/v2/ConnectedMotionGroup.ts
+const MOTION_DELTA_THRESHOLD$1 = 1e-4;
+/**
+* Store representing the current state of a connected motion group.
+*/
+var ConnectedMotionGroup = class ConnectedMotionGroup {
+	static async connect(nova, motionGroupId) {
+		const [_motionGroupIndex, controllerId] = motionGroupId.split("@");
+		const controller = await nova.api.controller.getCurrentRobotControllerState(controllerId);
+		const motionGroup = controller?.motion_groups.find((mg) => mg.motion_group === motionGroupId);
+		if (!controller || !motionGroup) throw new Error(`Controller ${controllerId} or motion group ${motionGroupId} not found`);
+		const motionStateSocket = nova.openReconnectingWebsocket(`/controllers/${controllerId}/motion-groups/${motionGroupId}/state-stream`);
+		const firstMessage = await motionStateSocket.firstMessage();
+		const initialMotionState = tryParseJson(firstMessage.data)?.result;
+		if (!initialMotionState) throw new Error(`Unable to parse initial motion state message ${firstMessage.data}`);
+		console.log(`Connected motion state websocket to motion group ${motionGroup.motion_group}. Initial state:\n  `, initialMotionState);
+		const isVirtual = (await nova.api.controller.getRobotController(controller.controller)).configuration.kind === "VirtualController";
+		const description = await nova.api.motionGroup.getMotionGroupDescription(controllerId, motionGroup.motion_group);
+		const tcps = Object.entries(description.tcps || {}).map(([id, tcp]) => ({
+			id,
+			readable_name: tcp.name,
+			position: tcp.pose.position,
+			orientation: tcp.pose.orientation
+		}));
+		const controllerStateSocket = nova.openReconnectingWebsocket(`/controllers/${controller.controller}/state-stream?response_rate=1000`);
+		const firstControllerMessage = await controllerStateSocket.firstMessage();
+		const initialControllerState = tryParseJson(firstControllerMessage.data)?.result;
+		if (!initialControllerState) throw new Error(`Unable to parse initial controller state message ${firstControllerMessage.data}`);
+		console.log(`Connected controller state websocket to controller ${controller.controller}. Initial state:\n  `, initialControllerState);
+		return new ConnectedMotionGroup(nova, controller, motionGroup, initialMotionState, motionStateSocket, isVirtual, tcps, description, initialControllerState, controllerStateSocket);
+	}
+	constructor(nova, controller, motionGroup, initialMotionState, motionStateSocket, isVirtual, tcps, description, initialControllerState, controllerStateSocket) {
+		this.nova = nova;
+		this.controller = controller;
+		this.motionGroup = motionGroup;
+		this.initialMotionState = initialMotionState;
+		this.motionStateSocket = motionStateSocket;
+		this.isVirtual = isVirtual;
+		this.tcps = tcps;
+		this.description = description;
+		this.initialControllerState = initialControllerState;
+		this.controllerStateSocket = controllerStateSocket;
+		this.connectedJoggingSocket = null;
+		this.joggingVelocity = 10;
+		this.activationState = "inactive";
+		this.rapidlyChangingMotionState = initialMotionState;
+		this.controllerState = initialControllerState;
+		controllerStateSocket.addEventListener("message", (event) => {
+			const data = tryParseJson(event.data)?.result;
+			if (!data) return;
+			runInAction(() => {
+				this.controllerState = data;
+			});
+		});
+		motionStateSocket.addEventListener("message", (event) => {
+			const latestMotionState = tryParseJson(event.data)?.result;
+			if (!latestMotionState) throw new Error(`Failed to get motion state for ${this.motionGroupId}: ${event.data}`);
+			if (!jointValuesEqual(this.rapidlyChangingMotionState.joint_position, latestMotionState.joint_position, MOTION_DELTA_THRESHOLD$1)) runInAction(() => {
+				this.rapidlyChangingMotionState = latestMotionState;
+			});
+			if (!tcpMotionEqual(this.rapidlyChangingMotionState, latestMotionState, MOTION_DELTA_THRESHOLD$1)) runInAction(() => {
+				this.rapidlyChangingMotionState.tcp_pose = latestMotionState.tcp_pose;
+			});
+			if (this.rapidlyChangingMotionState.standstill !== latestMotionState.standstill) runInAction(() => {
+				this.rapidlyChangingMotionState.standstill = latestMotionState.standstill;
+			});
+		});
+		makeAutoObservable(this);
+	}
+	get motionGroupId() {
+		return this.motionGroup.motion_group;
+	}
+	get controllerId() {
+		return this.controller.controller;
+	}
+	get modelFromController() {
+		return this.description.motion_group_model;
+	}
+	get wandelscriptIdentifier() {
+		const num = this.motionGroupId.split("@")[0];
+		return `${this.controllerId.replaceAll("-", "_")}_${num}`;
+	}
+	/** Jogging velocity in radians for rotation and joint movement */
+	get joggingVelocityRads() {
+		return this.joggingVelocity * Math.PI / 180;
+	}
+	get joints() {
+		return this.initialMotionState.joint_position.map((_, i) => {
+			return { index: i };
+		});
+	}
+	get dhParameters() {
+		return this.description.dh_parameters;
+	}
+	get safetyZones() {
+		return this.description.safety_zones;
+	}
+	/** Gets the robot mounting position offset in 3D viz coordinates */
+	get mountingPosition() {
+		if (!this.description.mounting) return [
+			0,
+			0,
+			0
+		];
+		return [
+			(this.description.mounting.position?.[0] || 0) / 1e3,
+			(this.description.mounting.position?.[1] || 0) / 1e3,
+			(this.description.mounting.position?.[2] || 0) / 1e3
+		];
+	}
+	/** Gets the robot mounting position rotation in 3D viz coordinates */
+	get mountingQuaternion() {
+		const rotationVector = new THREE.Vector3(this.description.mounting?.orientation?.[0] || 0, this.description.mounting?.orientation?.[1] || 0, this.description.mounting?.orientation?.[2] || 0);
+		const magnitude = rotationVector.length();
+		const axis = rotationVector.normalize();
+		return new THREE.Quaternion().setFromAxisAngle(axis, magnitude);
+	}
+	/**
+	* Whether the controller is currently in a safety state
+	* corresponding to an emergency stop
+	*/
+	get isEstopActive() {
+		return ["SAFETY_STATE_ROBOT_EMERGENCY_STOP", "SAFETY_STATE_DEVICE_EMERGENCY_STOP"].includes(this.controllerState.safety_state);
+	}
+	/**
+	* Whether the controller is in a safety state
+	* that may be non-functional for robot pad purposes
+	*/
+	get isMoveableSafetyState() {
+		return ["SAFETY_STATE_NORMAL", "SAFETY_STATE_REDUCED"].includes(this.controllerState.safety_state);
+	}
+	/**
+	* Whether the controller is in an operation mode that allows movement
+	*/
+	get isMoveableOperationMode() {
+		return [
+			"OPERATION_MODE_AUTO",
+			"OPERATION_MODE_MANUAL",
+			"OPERATION_MODE_MANUAL_T1",
+			"OPERATION_MODE_MANUAL_T2"
+		].includes(this.controllerState.operation_mode);
+	}
+	/**
+	* Whether the robot is currently active and can be moved, based on the
+	* safety state, operation mode and servo toggle activation state.
+	*/
+	get canBeMoved() {
+		return this.isMoveableSafetyState && this.isMoveableOperationMode && this.activationState === "active";
+	}
+	async deactivate() {
+		if (this.activationState !== "active") {
+			console.error("Tried to deactivate while already deactivating");
+			return;
+		}
+		runInAction(() => {
+			this.activationState = "deactivating";
+		});
+		try {
+			await this.nova.api.controller.setDefaultMode(this.controllerId, "ROBOT_SYSTEM_MODE_MONITOR");
+			runInAction(() => {
+				this.activationState = "inactive";
+			});
+		} catch (err) {
+			runInAction(() => {
+				this.activationState = "active";
+			});
+			throw err;
+		}
+	}
+	async activate() {
+		if (this.activationState !== "inactive") {
+			console.error("Tried to activate while already activating");
+			return;
+		}
+		runInAction(() => {
+			this.activationState = "activating";
+		});
+		try {
+			await this.nova.api.controller.setDefaultMode(this.controllerId, "ROBOT_SYSTEM_MODE_CONTROL");
+			runInAction(() => {
+				this.activationState = "active";
+			});
+		} catch (err) {
+			runInAction(() => {
+				this.activationState = "inactive";
+			});
+			throw err;
+		}
+	}
+	toggleActivation() {
+		if (this.activationState === "inactive") this.activate();
+		else if (this.activationState === "active") this.deactivate();
+	}
+	dispose() {
+		this.motionStateSocket.close();
+		if (this.connectedJoggingSocket) this.connectedJoggingSocket.close();
+	}
+	setJoggingVelocity(velocity) {
+		this.joggingVelocity = velocity;
+	}
+};
+
+//#endregion
 //#region src/lib/v2/NovaCellAPIClient.ts
 /**
 * API client providing type-safe access to all the Nova API REST endpoints
@@ -79,7 +310,6 @@ var NovaCellAPIClient = class {
 //#endregion
 //#region src/lib/v2/mock/MockNovaInstance.ts
 /**
-* EXPERIMENTAL
 * Ultra-simplified mock Nova server for testing stuff
 */
 var MockNovaInstance = class {
@@ -88,6 +318,437 @@ var MockNovaInstance = class {
 	}
 	async handleAPIRequest(config) {
 		const apiHandlers = [
+			{
+				method: "GET",
+				path: "/cells/:cellId/controllers/:controllerId/state",
+				handle() {
+					return {
+						mode: "MODE_CONTROL",
+						last_error: [],
+						timestamp: "2025-10-16T09:19:26.634534092Z",
+						sequence_number: 1054764,
+						controller: "mock-ur5e",
+						operation_mode: "OPERATION_MODE_AUTO",
+						safety_state: "SAFETY_STATE_NORMAL",
+						velocity_override: 100,
+						motion_groups: [{
+							timestamp: "2025-10-16T09:19:26.634534092Z",
+							sequence_number: 1054764,
+							motion_group: "0@mock-ur5e",
+							controller: "mock-ur5e",
+							joint_position: [
+								1.487959623336792,
+								-1.8501918315887451,
+								1.8003005981445312,
+								6.034560203552246,
+								1.4921919107437134,
+								1.593459963798523
+							],
+							joint_limit_reached: { limit_reached: [
+								false,
+								false,
+								false,
+								false,
+								false,
+								false
+							] },
+							joint_torque: [],
+							joint_current: [
+								0,
+								0,
+								0,
+								0,
+								0,
+								0
+							],
+							flange_pose: {
+								position: [
+									107.6452433732927,
+									-409.0402987746852,
+									524.2402132330305
+								],
+								orientation: [
+									.9874434028353319,
+									-.986571714997442,
+									1.3336589451098142
+								]
+							},
+							tcp: "Flange",
+							tcp_pose: {
+								position: [
+									107.6452433732927,
+									-409.0402987746852,
+									524.2402132330305
+								],
+								orientation: [
+									.9874434028353319,
+									-.986571714997442,
+									1.3336589451098142
+								]
+							},
+							payload: "",
+							coordinate_system: "",
+							standstill: true
+						}]
+					};
+				}
+			},
+			{
+				method: "GET",
+				path: "/cells/:cellId/controllers/:controllerId/motion-groups/:motionGroupId/description",
+				handle() {
+					return {
+						motion_group_model: "UniversalRobots_UR5e",
+						mounting: {
+							position: [
+								0,
+								0,
+								0
+							],
+							orientation: [
+								0,
+								0,
+								0
+							]
+						},
+						tcps: {
+							Flange: {
+								name: "Default-Flange",
+								pose: {
+									position: [
+										0,
+										0,
+										0
+									],
+									orientation: [
+										0,
+										0,
+										0
+									]
+								}
+							},
+							"complex-tcp-position": {
+								name: "Complex TCP Position",
+								pose: {
+									position: [
+										-200,
+										300,
+										150
+									],
+									orientation: [
+										-.12139440409113832,
+										-.06356210998212003,
+										-.2023240068185639
+									]
+								}
+							},
+							"offset-150mm-xy": {
+								name: "-150mm XY Offset",
+								pose: {
+									position: [
+										-150,
+										-150,
+										0
+									],
+									orientation: [
+										0,
+										0,
+										0
+									]
+								}
+							},
+							"rotated-90deg-z": {
+								name: "90° Z Axis Rotation",
+								pose: {
+									position: [
+										0,
+										0,
+										0
+									],
+									orientation: [
+										0,
+										0,
+										1.5708
+									]
+								}
+							}
+						},
+						payloads: { "FPay-0": {
+							name: "FPay-0",
+							payload: 0,
+							center_of_mass: [
+								0,
+								0,
+								0
+							],
+							moment_of_inertia: [
+								0,
+								0,
+								0
+							]
+						} },
+						cycle_time: 8,
+						dh_parameters: [
+							{
+								alpha: 1.5707963267948966,
+								d: 162.25
+							},
+							{ a: -425 },
+							{ a: -392.2 },
+							{
+								alpha: 1.5707963267948966,
+								d: 133.3
+							},
+							{
+								alpha: -1.5707963267948966,
+								d: 99.7
+							},
+							{ d: 99.6 }
+						],
+						operation_limits: {
+							auto_limits: {
+								joints: [
+									{
+										position: {
+											lower_limit: -6.283185307179586,
+											upper_limit: 6.283185307179586
+										},
+										velocity: 3.34159255027771,
+										acceleration: 40,
+										torque: 150
+									},
+									{
+										position: {
+											lower_limit: -6.283185307179586,
+											upper_limit: 6.283185307179586
+										},
+										velocity: 3.34159255027771,
+										acceleration: 40,
+										torque: 150
+									},
+									{
+										position: {
+											lower_limit: -6.283185307179586,
+											upper_limit: 6.283185307179586
+										},
+										velocity: 3.34159255027771,
+										acceleration: 40,
+										torque: 150
+									},
+									{
+										position: {
+											lower_limit: -6.283185307179586,
+											upper_limit: 6.283185307179586
+										},
+										velocity: 3.34159255027771,
+										acceleration: 40,
+										torque: 28
+									},
+									{
+										position: {
+											lower_limit: -6.283185307179586,
+											upper_limit: 6.283185307179586
+										},
+										velocity: 3.34159255027771,
+										acceleration: 40,
+										torque: 28
+									},
+									{
+										position: {
+											lower_limit: -6.283185307179586,
+											upper_limit: 6.283185307179586
+										},
+										velocity: 3.34159255027771,
+										acceleration: 40,
+										torque: 28
+									}
+								],
+								tcp: { velocity: 5e3 },
+								elbow: { velocity: 5e3 },
+								flange: { velocity: 5e3 }
+							},
+							manual_limits: {
+								joints: [
+									{
+										position: {
+											lower_limit: -6.283185307179586,
+											upper_limit: 6.283185307179586
+										},
+										velocity: 3.34159255027771,
+										acceleration: 40,
+										torque: 150
+									},
+									{
+										position: {
+											lower_limit: -6.283185307179586,
+											upper_limit: 6.283185307179586
+										},
+										velocity: 3.34159255027771,
+										acceleration: 40,
+										torque: 150
+									},
+									{
+										position: {
+											lower_limit: -6.283185307179586,
+											upper_limit: 6.283185307179586
+										},
+										velocity: 3.34159255027771,
+										acceleration: 40,
+										torque: 150
+									},
+									{
+										position: {
+											lower_limit: -6.283185307179586,
+											upper_limit: 6.283185307179586
+										},
+										velocity: 3.34159255027771,
+										acceleration: 40,
+										torque: 28
+									},
+									{
+										position: {
+											lower_limit: -6.283185307179586,
+											upper_limit: 6.283185307179586
+										},
+										velocity: 3.34159255027771,
+										acceleration: 40,
+										torque: 28
+									},
+									{
+										position: {
+											lower_limit: -6.283185307179586,
+											upper_limit: 6.283185307179586
+										},
+										velocity: 3.34159255027771,
+										acceleration: 40,
+										torque: 28
+									}
+								],
+								tcp: { velocity: 5e3 }
+							},
+							manual_t1_limits: {
+								joints: [
+									{
+										position: {
+											lower_limit: -6.283185307179586,
+											upper_limit: 6.283185307179586
+										},
+										velocity: 3.34159255027771,
+										acceleration: 40,
+										torque: 150
+									},
+									{
+										position: {
+											lower_limit: -6.283185307179586,
+											upper_limit: 6.283185307179586
+										},
+										velocity: 3.34159255027771,
+										acceleration: 40,
+										torque: 150
+									},
+									{
+										position: {
+											lower_limit: -6.283185307179586,
+											upper_limit: 6.283185307179586
+										},
+										velocity: 3.34159255027771,
+										acceleration: 40,
+										torque: 150
+									},
+									{
+										position: {
+											lower_limit: -6.283185307179586,
+											upper_limit: 6.283185307179586
+										},
+										velocity: 3.34159255027771,
+										acceleration: 40,
+										torque: 28
+									},
+									{
+										position: {
+											lower_limit: -6.283185307179586,
+											upper_limit: 6.283185307179586
+										},
+										velocity: 3.34159255027771,
+										acceleration: 40,
+										torque: 28
+									},
+									{
+										position: {
+											lower_limit: -6.283185307179586,
+											upper_limit: 6.283185307179586
+										},
+										velocity: 3.34159255027771,
+										acceleration: 40,
+										torque: 28
+									}
+								],
+								tcp: { velocity: 5e3 }
+							},
+							manual_t2_limits: {
+								joints: [
+									{
+										position: {
+											lower_limit: -6.283185307179586,
+											upper_limit: 6.283185307179586
+										},
+										velocity: 3.34159255027771,
+										acceleration: 40,
+										torque: 150
+									},
+									{
+										position: {
+											lower_limit: -6.283185307179586,
+											upper_limit: 6.283185307179586
+										},
+										velocity: 3.34159255027771,
+										acceleration: 40,
+										torque: 150
+									},
+									{
+										position: {
+											lower_limit: -6.283185307179586,
+											upper_limit: 6.283185307179586
+										},
+										velocity: 3.34159255027771,
+										acceleration: 40,
+										torque: 150
+									},
+									{
+										position: {
+											lower_limit: -6.283185307179586,
+											upper_limit: 6.283185307179586
+										},
+										velocity: 3.34159255027771,
+										acceleration: 40,
+										torque: 28
+									},
+									{
+										position: {
+											lower_limit: -6.283185307179586,
+											upper_limit: 6.283185307179586
+										},
+										velocity: 3.34159255027771,
+										acceleration: 40,
+										torque: 28
+									},
+									{
+										position: {
+											lower_limit: -6.283185307179586,
+											upper_limit: 6.283185307179586
+										},
+										velocity: 3.34159255027771,
+										acceleration: 40,
+										torque: 28
+									}
+								],
+								tcp: { velocity: 5e3 }
+							}
+						},
+						serial_number: "WBVirtualRobot"
+					};
+				}
+			},
 			{
 				method: "GET",
 				path: "/cells/:cellId/controllers",
@@ -1254,6 +1915,380 @@ const defaultMotionState = { result: {
 	}
 } };
 
+//#endregion
+//#region src/lib/v2/MotionStreamConnection.ts
+const MOTION_DELTA_THRESHOLD = 1e-4;
+function unwrapRotationVector(newRotationVectorApi, currentRotationVectorApi) {
+	const currentRotationVector = new Vector3(currentRotationVectorApi[0], currentRotationVectorApi[1], currentRotationVectorApi[2]);
+	const newRotationVector = new Vector3(newRotationVectorApi[0], newRotationVectorApi[1], newRotationVectorApi[2]);
+	const currentAngle = currentRotationVector.length();
+	const currentAxis = currentRotationVector.normalize();
+	let newAngle = newRotationVector.length();
+	let newAxis = newRotationVector.normalize();
+	if (newAxis.dot(currentAxis) < 0) {
+		newAngle = -newAngle;
+		newAxis = newAxis.multiplyScalar(-1);
+	}
+	let angleDifference = newAngle - currentAngle;
+	angleDifference -= 2 * Math.PI * Math.floor((angleDifference + Math.PI) / (2 * Math.PI));
+	newAngle = currentAngle + angleDifference;
+	return [...newAxis.multiplyScalar(newAngle)];
+}
+/**
+* Store representing the current state of a connected motion group.
+*/
+var MotionStreamConnection = class MotionStreamConnection {
+	static async open(nova, motionGroupId) {
+		const [_motionGroupIndex, controllerId] = motionGroupId.split("@");
+		const controller = await nova.api.controller.getCurrentRobotControllerState(controllerId);
+		const motionGroup = controller?.motion_groups.find((mg) => mg.motion_group === motionGroupId);
+		if (!controller || !motionGroup) throw new Error(`Controller ${controllerId} or motion group ${motionGroupId} not found`);
+		const motionStateSocket = nova.openReconnectingWebsocket(`/controllers/${controllerId}/motion-groups/${motionGroupId}/state-stream`);
+		const firstMessage = await motionStateSocket.firstMessage();
+		const initialMotionState = tryParseJson(firstMessage.data)?.result;
+		if (!initialMotionState) throw new Error(`Unable to parse initial motion state message ${firstMessage.data}`);
+		console.log(`Connected motion state websocket to motion group ${motionGroup.motion_group}. Initial state:\n  `, initialMotionState);
+		return new MotionStreamConnection(nova, controller, motionGroup, await nova.api.motionGroup.getMotionGroupDescription(controllerId, motionGroup.motion_group), initialMotionState, motionStateSocket);
+	}
+	constructor(nova, controller, motionGroup, description, initialMotionState, motionStateSocket) {
+		this.nova = nova;
+		this.controller = controller;
+		this.motionGroup = motionGroup;
+		this.description = description;
+		this.initialMotionState = initialMotionState;
+		this.motionStateSocket = motionStateSocket;
+		this.rapidlyChangingMotionState = initialMotionState;
+		motionStateSocket.addEventListener("message", (event) => {
+			const latestMotionState = tryParseJson(event.data)?.result;
+			if (!latestMotionState) throw new Error(`Failed to get motion state for ${this.motionGroupId}: ${event.data}`);
+			if (!jointValuesEqual(this.rapidlyChangingMotionState.joint_position, latestMotionState.joint_position, MOTION_DELTA_THRESHOLD)) runInAction(() => {
+				this.rapidlyChangingMotionState = latestMotionState;
+			});
+			if (!tcpMotionEqual(this.rapidlyChangingMotionState, latestMotionState, MOTION_DELTA_THRESHOLD)) runInAction(() => {
+				if (this.rapidlyChangingMotionState.tcp_pose == null) this.rapidlyChangingMotionState.tcp_pose = latestMotionState.tcp_pose;
+				else if (latestMotionState.tcp_pose?.orientation && latestMotionState.tcp_pose?.position && this.rapidlyChangingMotionState.tcp_pose?.orientation) this.rapidlyChangingMotionState.tcp_pose = {
+					position: latestMotionState.tcp_pose.position,
+					orientation: unwrapRotationVector(latestMotionState.tcp_pose.orientation, this.rapidlyChangingMotionState.tcp_pose.orientation)
+				};
+				else console.warn("Received incomplete tcp_pose, ignoring", latestMotionState.tcp_pose);
+			});
+			if (this.rapidlyChangingMotionState.standstill !== latestMotionState.standstill) runInAction(() => {
+				this.rapidlyChangingMotionState.standstill = latestMotionState.standstill;
+			});
+		});
+		makeAutoObservable(this);
+	}
+	get motionGroupId() {
+		return this.motionGroup.motion_group;
+	}
+	get controllerId() {
+		return this.controller.controller;
+	}
+	get wandelscriptIdentifier() {
+		const num = this.motionGroupId.split("@")[0];
+		return `${this.controllerId.replaceAll("-", "_")}_${num}`;
+	}
+	get joints() {
+		return this.initialMotionState.joint_position.map((_, i) => {
+			return { index: i };
+		});
+	}
+	dispose() {
+		this.motionStateSocket.close();
+	}
+};
+
+//#endregion
+//#region src/lib/v2/JoggerConnection.ts
+var JoggerConnection = class JoggerConnection {
+	/**
+	* Initialize the jogging connection using jogging endpoint or trajectory endpoint depending on the selected mode.
+	*
+	* @param nova - The Nova client instance
+	* @param motionGroupId - The ID of the motion group to connect to
+	* @param options - Configuration options for the jogger connection
+	* @param options.mode - The jogging mode to initialize:
+	*   - "jogging": Continuous jogging mode with persistent websocket for real-time velocity commands
+	*   - "trajectory": Incremental jogging mode for fixed-distance motions via trajectory planning
+	*   - "off": No jogging enabled, all websockets closed (default)
+	* @param options.timeout - Timeout in milliseconds for websocket initialization (default: 5000ms)
+	* @param options.tcp - TCP frame to use for motions (default: from motion group)
+	* //param options.coordinateSystem - Coordinate system for jogging commands (default: "world"). Please note: Currently not implemented
+	* @param options.orientation - If set to "tool", jogging TcpVelocityRequest will use `use_tool_coordinate_system` option (default: "world")
+	* @param options.onError - Error handler for websocket errors
+	* @returns Promise resolving to initialized JoggerConnection instance
+	*/
+	static async open(nova, motionGroupId, options = {}) {
+		const jogger = new JoggerConnection(await nova.connectMotionStream(motionGroupId), options);
+		await jogger.setJoggingMode(jogger.mode);
+		return jogger;
+	}
+	constructor(motionStream, options = {}) {
+		this.motionStream = motionStream;
+		this.options = options;
+		this.ENDPOINT_JOGGING = "/execution/jogging";
+		this.ENDPOINT_TRAJECTORY = "/execution/trajectory";
+		this.DEFAULT_MODE = "off";
+		this.DEFAULT_TCP = "Flange";
+		this.DEFAULT_INIT_TIMEOUT = 5e3;
+		this.DEFAULT_ORIENTATION = "world";
+		this.mode = "off";
+		this.joggingSocket = null;
+		this.trajectorySocket = null;
+		this.timeout = this.DEFAULT_INIT_TIMEOUT;
+		this.tcp = options?.tcp || motionStream.motionGroup.tcp || this.DEFAULT_TCP;
+		this.orientation = options?.orientation || this.DEFAULT_ORIENTATION;
+		this.timeout = options?.timeout || this.DEFAULT_INIT_TIMEOUT;
+		this.mode = options?.mode || this.DEFAULT_MODE;
+		this.onError = options?.onError;
+	}
+	async updateOptions(options) {
+		if (options.tcp) this.tcp = options.tcp;
+		if (options.timeout) this.timeout = options.timeout;
+		if (options.mode) this.mode = options.mode;
+		if (options.orientation) this.orientation = options.orientation;
+		if (options.onError) this.onError = options.onError;
+		this.setJoggingMode(this.mode, false);
+	}
+	get motionGroupId() {
+		return this.motionStream.motionGroupId;
+	}
+	get nova() {
+		return this.motionStream.nova;
+	}
+	get numJoints() {
+		return this.motionStream.joints.length;
+	}
+	async stop() {
+		if (this.joggingSocket) {
+			const velocity = new Array(this.numJoints).fill(0);
+			this.joggingSocket.sendJson({
+				message_type: "JointVelocityRequest",
+				velocity
+			});
+		}
+		if (this.trajectorySocket) this.trajectorySocket.sendJson({ message_type: "PauseMovementRequest" });
+	}
+	async dispose() {
+		const sockets = [this.joggingSocket, this.trajectorySocket].filter((s) => s !== null);
+		sockets.forEach((s) => {
+			s.dispose();
+		});
+		this.joggingSocket = null;
+		this.trajectorySocket = null;
+		return Promise.all(sockets.map((s) => s.closed()));
+	}
+	async setJoggingMode(mode, skipReinitializeIfSameMode = true) {
+		if (this.mode === mode && skipReinitializeIfSameMode) return;
+		this.dispose();
+		this.mode = mode;
+		if (this.mode === "jogging") return this.initializeJoggingWebsocket();
+	}
+	async initializeJoggingWebsocket() {
+		return new Promise((resolve, reject) => {
+			const connectionFailedTimeout = setTimeout(() => {
+				reject(/* @__PURE__ */ new Error(`Jogging initialization timeout after ${this.timeout} seconds`));
+			}, this.timeout);
+			this.joggingSocket = this.nova.openReconnectingWebsocket(this.ENDPOINT_JOGGING);
+			this.joggingSocket.addEventListener("message", (ev) => {
+				const data = tryParseJson(ev.data);
+				if (data?.result?.kind === "INITIALIZE_RECEIVED") {
+					clearTimeout(connectionFailedTimeout);
+					resolve();
+					return;
+				}
+				if (data && "error" in data || data?.result?.kind === "MOTION_ERROR") {
+					clearTimeout(connectionFailedTimeout);
+					if (this.onError) this.onError(ev.data);
+					else reject(new Error(ev.data));
+				}
+			});
+			this.joggingSocket.sendJson({
+				message_type: "InitializeJoggingRequest",
+				motion_group: this.motionGroupId,
+				tcp: this.tcp
+			});
+		});
+	}
+	/**
+	* Jogging: Start rotation of a single robot joint at the specified velocity
+	*/
+	async rotateJoints({ joint, direction, velocityRadsPerSec }) {
+		if (!this.joggingSocket || this.mode !== "jogging") throw new Error("Joint jogging websocket not connected; create one by setting jogging mode to 'jogging'");
+		const velocity = new Array(this.numJoints).fill(0);
+		velocity[joint] = direction === "-" ? -velocityRadsPerSec : velocityRadsPerSec;
+		this.joggingSocket.sendJson({
+			message_type: "JointVelocityRequest",
+			velocity
+		});
+	}
+	/**
+	* Jogging: Start the TCP moving along a specified axis at a given velocity
+	*/
+	async translateTCP({ axis, direction, velocityMmPerSec }) {
+		if (!this.joggingSocket || this.mode !== "jogging") throw new Error("Continuous jogging websocket not connected; create one by setting jogging mode to 'jogging'");
+		const rotation = [
+			0,
+			0,
+			0
+		];
+		const translation = [
+			0,
+			0,
+			0
+		];
+		translation[XYZ_TO_VECTOR[axis]] = direction === "-" ? -velocityMmPerSec : velocityMmPerSec;
+		this.joggingSocket.sendJson({
+			message_type: "TcpVelocityRequest",
+			translation,
+			rotation,
+			use_tool_coordinate_system: this.orientation === "tool"
+		});
+	}
+	/**
+	* Jogging: Start the TCP rotating around a specified axis at a given velocity
+	*/
+	async rotateTCP({ axis, direction, velocityRadsPerSec }) {
+		if (!this.joggingSocket || this.mode !== "jogging") throw new Error("Continuous jogging websocket not connected; create one by setting jogging mode to 'jogging'");
+		const rotation = [
+			0,
+			0,
+			0
+		];
+		const translation = [
+			0,
+			0,
+			0
+		];
+		rotation[XYZ_TO_VECTOR[axis]] = direction === "-" ? -velocityRadsPerSec : velocityRadsPerSec;
+		this.joggingSocket.sendJson({
+			message_type: "TcpVelocityRequest",
+			translation,
+			rotation
+		});
+	}
+	/**
+	* Trajectory jogging:
+	*
+	* Move the robot by a fixed distance in a single cartesian
+	* axis, either rotating or translating relative to the TCP.
+	* Promise resolves only after the motion has completed.
+	*/
+	async runIncrementalCartesianMotion({ currentTcpPose, currentJoints, coordSystemId, velocityInRelevantUnits, axis, direction, motion }) {
+		const commands = [];
+		if (this.mode !== "trajectory") throw new Error("Set jogging mode to 'trajectory' to run incremental cartesian motions");
+		if (motion.type === "translate") {
+			if (!currentTcpPose.position) throw new Error("Current pose has no position, cannot perform translation");
+			const targetTcpPosition = [...currentTcpPose.position];
+			targetTcpPosition[XYZ_TO_VECTOR[axis]] += motion.distanceMm * (direction === "-" ? -1 : 1);
+			commands.push({
+				limits_override: { tcp_velocity_limit: velocityInRelevantUnits },
+				path: {
+					path_definition_name: "PathLine",
+					target_pose: {
+						position: targetTcpPosition,
+						orientation: currentTcpPose.orientation
+					}
+				}
+			});
+		} else if (motion.type === "rotate") {
+			if (!currentTcpPose.orientation) throw new Error("Current pose has no orientation, cannot perform rotation");
+			const currentRotationVector = new Vector3$1(currentTcpPose.orientation[0], currentTcpPose.orientation[1], currentTcpPose.orientation[2]);
+			const currentRotationRad = currentRotationVector.length();
+			const currentRotationDirection = currentRotationVector.clone().normalize();
+			const differenceRotationRad = motion.distanceRads * (direction === "-" ? -1 : 1);
+			const differenceRotationDirection = new Vector3$1(0, 0, 0);
+			differenceRotationDirection[axis] = 1;
+			const f1 = Math.cos(.5 * differenceRotationRad) * Math.cos(.5 * currentRotationRad);
+			const f2 = Math.sin(.5 * differenceRotationRad) * Math.sin(.5 * currentRotationRad);
+			const f3 = Math.sin(.5 * differenceRotationRad) * Math.cos(.5 * currentRotationRad);
+			const f4 = Math.cos(.5 * differenceRotationRad) * Math.sin(.5 * currentRotationRad);
+			const dotProduct = differenceRotationDirection.dot(currentRotationDirection);
+			const crossProduct = differenceRotationDirection.clone().cross(currentRotationDirection);
+			const newRotationRad = 2 * Math.acos(f1 - f2 * dotProduct);
+			const f5 = newRotationRad / Math.sin(.5 * newRotationRad);
+			const targetTcpOrientation = new Vector3$1().addScaledVector(crossProduct, f2).addScaledVector(differenceRotationDirection, f3).addScaledVector(currentRotationDirection, f4).multiplyScalar(f5);
+			commands.push({
+				limits_override: { tcp_orientation_velocity_limit: velocityInRelevantUnits },
+				path: {
+					path_definition_name: "PathLine",
+					target_pose: {
+						position: currentTcpPose.position,
+						orientation: [...targetTcpOrientation]
+					}
+				}
+			});
+		}
+		const description = this.motionStream.description;
+		if (description.cycle_time === void 0) {
+			console.warn("Current motion group has no cycle time, cannot plan jogging motion");
+			return;
+		}
+		const motion_group_setup = {
+			motion_group_model: description.motion_group_model,
+			cycle_time: description.cycle_time,
+			mounting: description.mounting,
+			global: description.operation_limits.auto_limits
+		};
+		const motionPlanRes = await this.nova.api.trajectoryPlanning.planTrajectory({
+			motion_group_setup,
+			start_joint_position: currentJoints,
+			motion_commands: commands
+		});
+		const trajectoryData = motionPlanRes.response;
+		if (!trajectoryData) throw new Error(`Failed to plan jogging increment motion ${JSON.stringify(motionPlanRes)}`);
+		if (this.trajectorySocket) {
+			console.warn("Trajectory jogging websocket already open; will close");
+			this.trajectorySocket.dispose();
+		}
+		this.trajectorySocket = this.nova.openReconnectingWebsocket(this.ENDPOINT_TRAJECTORY);
+		const messageInitializeMovementResponse = (result) => {
+			if (!result || result.add_trajectory_error || result.message) if (this.onError) this.onError(result);
+			else throw new Error(result?.add_trajectory_error?.message || result?.message || "Failed to execute trajectory, unknown error");
+			if (!this.trajectorySocket) throw new Error(`Failed to execute trajectory, websocket not available anymore`);
+			this.trajectorySocket.sendJson({
+				message_type: "StartMovementRequest",
+				direction: "DIRECTION_FORWARD"
+			});
+		};
+		const waitForMovementToStartAndFinish = async () => {
+			await when(() => !this.motionStream.rapidlyChangingMotionState.standstill);
+			await when(() => this.motionStream.rapidlyChangingMotionState.standstill);
+			this.trajectorySocket?.dispose();
+			this.trajectorySocket = null;
+		};
+		const waitForMovementToFinish = async () => {
+			await when(() => this.motionStream.rapidlyChangingMotionState.standstill);
+			this.trajectorySocket?.dispose();
+			this.trajectorySocket = null;
+		};
+		const messageStartMovementResponse = async (data) => {
+			if (data?.message) if (this.onError) {
+				this.onError(data);
+				return;
+			} else throw new Error(data.message || "Failed to execute trajectory, unknown error");
+			if (this.motionStream.rapidlyChangingMotionState.standstill) await waitForMovementToStartAndFinish();
+			else await waitForMovementToFinish();
+		};
+		this.trajectorySocket.addEventListener("message", (ev) => {
+			const data = tryParseJson(ev.data);
+			if (!data?.result?.kind) throw new Error(`Failed to execute trajectory: Received invalid message ${ev.data}`);
+			if (data.result.kind === "INITIALIZE_RECEIVED") messageInitializeMovementResponse(data.result);
+			else if (data.result.kind === "START_RECEIVED") messageStartMovementResponse(data);
+			else throw new Error(`Failed to execute trajectory, cannot handle message type "${data.result.kind}"`);
+		});
+		this.trajectorySocket.sendJson({
+			message_type: "InitializeMovementRequest",
+			trajectory: {
+				message_type: "TrajectoryData",
+				motion_group: this.motionGroupId,
+				data: trajectoryData,
+				tcp: this.tcp
+			}
+		});
+	}
+};
+
 //#endregion
 //#region src/lib/v2/NovaClient.ts
 function permissiveInstanceUrlParse(url) {
@@ -1261,10 +2296,6 @@ function permissiveInstanceUrlParse(url) {
 	return new URL(url).toString();
 }
 /**
-* EXPERIMENTAL
-*
-* This client provides a starting point to migrate NOVA api v2.
-* As v2 is still in development, this client has to be considered unstable
 *
 * Client for connecting to a Nova instance and controlling robots.
 */
@@ -1272,15 +2303,14 @@ var NovaClient = class {
 	constructor(config) {
 		this.authPromise = null;
 		this.accessToken = null;
-		console.warn("Using experimental NOVA v2 client");
 		const cellId = config.cellId ?? "cell";
 		this.config = {
 			cellId,
-			...config,
-			instanceUrl: permissiveInstanceUrlParse(config.instanceUrl)
+			...config
 		};
 		this.accessToken = config.accessToken || availableStorage.getString("wbjs.access_token") || null;
 		if (this.config.instanceUrl === "https://mock.example.com") this.mock = new MockNovaInstance();
+		else this.config.instanceUrl = permissiveInstanceUrlParse(this.config.instanceUrl);
 		const axiosInstance = axios.create({
 			baseURL: urlJoin(this.config.instanceUrl, "/api/v2"),
 			headers: typeof window !== "undefined" && window.location.origin.includes("localhost") ? {} : { "X-Wandelbots-Client": "Wandelbots-Nova-JS-SDK" }
@@ -1312,7 +2342,7 @@ var NovaClient = class {
 		});
 		this.api = new NovaCellAPIClient(cellId, {
 			...config,
-			basePath: urlJoin(this.config.instanceUrl, "/api/v1"),
+			basePath: urlJoin(this.config.instanceUrl, "/api/v2"),
 			isJsonMime: (mime) => {
 				return mime === "application/json";
 			},
@@ -1337,7 +2367,7 @@ var NovaClient = class {
 		}
 	}
 	makeWebsocketURL(path) {
-		const url = new URL(urlJoin(this.config.instanceUrl, `/api/v1/cells/${this.config.cellId}`, path));
+		const url = new URL(urlJoin(this.config.instanceUrl, `/api/v2/cells/${this.config.cellId}`, path));
 		url.protocol = url.protocol.replace("http", "ws");
 		url.protocol = url.protocol.replace("https", "wss");
 		if (this.accessToken) url.searchParams.append("token", this.accessToken);
@@ -1355,8 +2385,48 @@ var NovaClient = class {
 	openReconnectingWebsocket(path) {
 		return new AutoReconnectingWebsocket(this.makeWebsocketURL(path), { mock: this.mock });
 	}
+	/**
+	* Connect to the motion state websocket(s) for a given motion group
+	*/
+	async connectMotionStream(motionGroupId) {
+		return await MotionStreamConnection.open(this, motionGroupId);
+	}
+	/**
+	* Connect to the jogging websocket(s) for a given motion group
+	*/
+	async connectJogger(motionGroupId, options = {}) {
+		return await JoggerConnection.open(this, motionGroupId, options);
+	}
+	async connectMotionGroups(motionGroupIds) {
+		return Promise.all(motionGroupIds.map((motionGroupId) => ConnectedMotionGroup.connect(this, motionGroupId)));
+	}
+	async connectMotionGroup(motionGroupId) {
+		return (await this.connectMotionGroups([motionGroupId]))[0];
+	}
 };
 
 //#endregion
-export { NovaCellAPIClient, NovaClient };
+//#region src/lib/v2/wandelscriptUtils.ts
+/**
+* Convert a Pose object representing a motion group position
+* into a string which represents that pose in Wandelscript.
+*/
+function poseToWandelscriptString(pose) {
+	const position = [
+		pose.position?.[0] ?? 0,
+		pose.position?.[1] ?? 0,
+		pose.position?.[2] ?? 0
+	];
+	const orientation = [
+		pose.orientation?.[0] ?? 0,
+		pose.orientation?.[1] ?? 0,
+		pose.orientation?.[2] ?? 0
+	];
+	const positionValues = position.map((v) => v.toFixed(1));
+	const rotationValues = orientation.map((v) => v.toFixed(4));
+	return `(${positionValues.concat(rotationValues).join(", ")})`;
+}
+
+//#endregion
+export { ConnectedMotionGroup, JoggerConnection, MotionStreamConnection, NovaCellAPIClient, NovaClient, poseToWandelscriptString };
 //# sourceMappingURL=index.js.map