@wandelbots/nova-js 4.3.0-pr.318.6592c26 → 4.3.0-pr.318.66ea9ed

package/dist/Nova-CVMwZBmE.d.mts

@@ -0,0 +1,84 @@
+import { Du as TrajectoryCachingApi, Ju as TrajectoryPlanningApi, Lo as MotionGroupApi, Mc as ProgramApi, Pn as ControllerApi, Ru as TrajectoryExecutionApi, Td as VirtualControllerInputsOutputsApi, Zl as StoreCollisionComponentsApi, _d as VirtualControllerApi, au as StoreObjectApi, fd as VersionApi, fn as Configuration, h as ApplicationApi, io as LicenseApi, kl as SessionApi, ps as NOVACloudApi, pt as CellApi, qa as KinematicsApi, qo as MotionGroupModelsApi, sa as JoggingApi, tl as RobotConfigurationsApi, tu as StoreCollisionSetupsApi, uu as SystemApi, x as BUSInputsOutputsApi, xd as VirtualControllerBehaviorApi, zn as ControllerInputsOutputsApi } from "./index-O_-XIJE-.mjs";
+import { n as MockNovaInstance, t as AutoReconnectingWebsocket } from "./AutoReconnectingWebsocket-NVyczzLi.mjs";
+import { AxiosInstance } from "axios";
+//#region src/lib/NovaAPIClient.d.ts
+type UnwrapAxiosResponseReturn<T> = T extends ((...a: any[]) => any) ? (...a: Parameters<T>) => Promise<Awaited<ReturnType<T>> extends {
+  data: infer D;
+} ? D : never> : never;
+type WithUnwrappedAxiosResponse<T> = { [P in keyof T]: UnwrapAxiosResponseReturn<T[P]>; };
+type NovaAPIClientOpts = Configuration & {
+  axiosInstance?: AxiosInstance;
+  mock?: boolean;
+};
+/**
+ * API client providing type-safe access to all the endpoints of a NOVA
+ * instance.
+ */
+declare class NovaAPIClient {
+  readonly opts: NovaAPIClientOpts;
+  readonly application: WithUnwrappedAxiosResponse<ApplicationApi>;
+  readonly busIOs: WithUnwrappedAxiosResponse<BUSInputsOutputsApi>;
+  readonly cell: WithUnwrappedAxiosResponse<CellApi>;
+  readonly controller: WithUnwrappedAxiosResponse<ControllerApi>;
+  readonly controllerIOs: WithUnwrappedAxiosResponse<ControllerInputsOutputsApi>;
+  readonly jogging: WithUnwrappedAxiosResponse<JoggingApi>;
+  readonly kinematics: WithUnwrappedAxiosResponse<KinematicsApi>;
+  readonly license: WithUnwrappedAxiosResponse<LicenseApi>;
+  readonly motionGroup: WithUnwrappedAxiosResponse<MotionGroupApi>;
+  readonly motionGroupModels: WithUnwrappedAxiosResponse<MotionGroupModelsApi>;
+  readonly novaCloud: WithUnwrappedAxiosResponse<NOVACloudApi>;
+  readonly program: WithUnwrappedAxiosResponse<ProgramApi>;
+  readonly robotConfigurations: WithUnwrappedAxiosResponse<RobotConfigurationsApi>;
+  readonly session: WithUnwrappedAxiosResponse<SessionApi>;
+  readonly storeCollisionComponents: WithUnwrappedAxiosResponse<StoreCollisionComponentsApi>;
+  readonly storeCollisionSetups: WithUnwrappedAxiosResponse<StoreCollisionSetupsApi>;
+  readonly storeObject: WithUnwrappedAxiosResponse<StoreObjectApi>;
+  readonly system: WithUnwrappedAxiosResponse<SystemApi>;
+  readonly trajectoryCaching: WithUnwrappedAxiosResponse<TrajectoryCachingApi>;
+  readonly trajectoryExecution: WithUnwrappedAxiosResponse<TrajectoryExecutionApi>;
+  readonly trajectoryPlanning: WithUnwrappedAxiosResponse<TrajectoryPlanningApi>;
+  readonly version: WithUnwrappedAxiosResponse<VersionApi>;
+  readonly virtualController: WithUnwrappedAxiosResponse<VirtualControllerApi>;
+  readonly virtualControllerBehavior: WithUnwrappedAxiosResponse<VirtualControllerBehaviorApi>;
+  readonly virtualControllerIOs: WithUnwrappedAxiosResponse<VirtualControllerInputsOutputsApi>;
+  constructor(opts: NovaAPIClientOpts);
+}
+//#endregion
+//#region src/lib/Nova.d.ts
+type NovaConfig = {
+  /**
+   * Url of the deployed NOVA instance to connect to
+   * e.g. https://saeattii.instance.wandelbots.io
+   */
+  instanceUrl: string;
+  /**
+   * Access token for Bearer authentication.
+   * If running on a NOVA instance, this can be automatically retrieved from
+   * the current session when omitted.
+   */
+  accessToken?: string;
+} & Omit<Configuration, "isJsonMime" | "basePath">;
+/**
+ *
+ * Client for connecting to a NOVA instance and controlling robots.
+ */
+declare class Nova {
+  readonly api: NovaAPIClient;
+  readonly config: NovaConfig;
+  readonly mock?: MockNovaInstance;
+  readonly instanceUrl: URL;
+  authPromise: Promise<string | null> | null;
+  accessToken: string | null;
+  constructor(config: NovaConfig);
+  renewAuthentication(): Promise<void>;
+  makeWebsocketURL(path: string): string;
+  /**
+   * Retrieve an AutoReconnectingWebsocket to the given path on the Nova instance.
+   * If you explicitly want to reconnect an existing websocket, call `reconnect`
+   * on the returned object.
+   */
+  openReconnectingWebsocket(path: string): AutoReconnectingWebsocket;
+}
+//#endregion
+export { NovaConfig as n, NovaAPIClient as r, Nova as t };
+//# sourceMappingURL=Nova-CVMwZBmE.d.mts.map

package/dist/Nova-CVMwZBmE.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Nova-CVMwZBmE.d.mts","names":[],"sources":["../src/lib/NovaAPIClient.ts","../src/lib/Nova.ts"],"mappings":";;;;KAmCK,0BAA0B,KAAK,eAAc,wBAEzC,GAAG,WAAW,OACd,QAAQ,QAAQ,WAAW;EAAc,YAAY;IAAM;KAG/D,2BAA2B,QAC7B,WAAW,IAAI,0BAA0B,EAAE;KAGzC,oBAAoB;EACvB,gBAAgB;EAChB;;;;;;cAuCW;WACF,MAAM;WAEN,aAAa,2BAA2B;WACxC,QAAQ,2BAA2B;WACnC,MAAM,2BAA2B;WACjC,YAAY,2BAA2B;WACvC,eAAe,2BAA2B;WAC1C,SAAS,2BAA2B;WACpC,YAAY,2BAA2B;WACvC,SAAS,2BAA2B;WACpC,aAAa,2BAA2B;WACxC,mBAAmB,2BAA2B;WAC9C,WAAW,2BAA2B;WACtC,SAAS,2BAA2B;WACpC,qBAAqB,2BAA2B;WAChD,SAAS,2BAA2B;WACpC,0BAA0B,2BAA2B;WACrD,sBAAsB,2BAA2B;WACjD,aAAa,2BAA2B;WACxC,QAAQ,2BAA2B;WACnC,mBAAmB,2BAA2B;WAC9C,qBAAqB,2BAA2B;WAChD,oBAAoB,2BAA2B;WAC/C,SAAS,2BAA2B;WACpC,mBAAmB,2BAA2B;WAC9C,2BAA2B,2BAA2B;WACtD,sBAAsB,2BAA2B;EAE9C,YAAA,MAAM;;;;KCvGR;;;;;EAKV;;;;;;EAOA;IACE,KAAK;;;;;cAMI;WACF,KAAK;WACL,QAAQ;WACR,OAAO;WACP,aAAa;EACtB,aAAa;EACb;EAEY,YAAA,QAAQ;EAqId,uBAAuB;EA4B7B,iBAAiB;;;;;;EAiBjB,0BAA0B,eAAY"}

package/dist/experimental/math/index.d.mts

@@ -1,4 +1,4 @@
-import { bc as Pose$1, t as Nova } from "../../Nova-DdbUm145.mjs";
+import { _c as Pose$1 } from "../../index-O_-XIJE-.mjs";
 //#region src/lib/experimental/math/Pose.d.ts
 /**
  * A `Pose` (position + axis-angle orientation) with methods for composing
@@ -6,10 +6,6 @@ import { bc as Pose$1, t as Nova } from "../../Nova-DdbUm145.mjs";
  * wire-format `PoseData` type (own `position`/`orientation` properties only,
  * no enumerable methods), so they can be passed directly back into API calls
  * that expect a pose.
- *
- * Poses returned from `NovaAPIClient`/`Nova` are automatically upgraded to
- * `Pose` instances; construct one directly only when you have a pose from
- * elsewhere (e.g. a websocket message).
  */
 declare class Pose implements Pose$1 {
   readonly position: number[];
@@ -28,80 +24,79 @@ declare class Pose implements Pose$1 {
   inverse(): Pose;
   /** Apply this pose's transform to a point, returning the transformed point. */
   transformPoint(point: number[]): number[];
-  /** Compare to another pose within a tolerance, since floating-point pose math rarely produces exact equality. */
-  equals(other: Pose$1, epsilon?: number): boolean;
+  /**
+   * Compare to another pose using separate position/orientation tolerances,
+   * matching wb-robotix's `Pose::isApprox()`: Euclidean distance for
+   * position, and quaternion angular distance for orientation - not a naive
+   * per-component diff, since two rotation vectors can represent nearly
+   * identical rotations while differing componentwise near a
+   * canonicalization boundary (e.g. close to the +/-pi wraparound).
+   */
+  isApprox(other: Pose$1, deltaPosition?: number, deltaOrientation?: number): boolean;
+  /**
+   * Position + orientation as a 6-element [x, y, z, roll, pitch, yaw] vector
+   * (Euler angles in rad, XYZ Tait-Bryan / Rx*Ry*Rz convention), matching
+   * wb-robotix's `Pose::toCartesian()`.
+   */
+  toCartesian(): number[];
+  /** Human-readable `[x, y, z][rx, ry, rz]` representation, matching wb-robotix's `Pose::string()`. */
+  toString(precision?: number): string;
   toJSON(): Pose$1;
 }
 //#endregion
-//#region src/lib/experimental/math/augmentMath.d.ts
-type PoseKeys = keyof Pose$1;
-type IsExactlyPoseData<T> = [Exclude<keyof T, PoseKeys>] extends [never] ? [Exclude<PoseKeys, keyof T>] extends [never] ? true : false : false;
-type MaxDepth = [unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown];
-type AugmentPosesCore<T, Depth extends readonly unknown[]> = Depth["length"] extends MaxDepth["length"] ? T : IsExactlyPoseData<T> extends true ? Pose : T extends readonly (infer U)[] ? DeepPoseAugmented<U, [...Depth, unknown]>[] : T extends object ? { [K in keyof T]: DeepPoseAugmented<T[K], [...Depth, unknown]>; } : T;
-/**
- * Type-level counterpart to `augmentPoses`: recursively replaces any
- * `PoseData`-shaped field with `Pose` (distributing over unions, e.g. so
- * optional `Pose | undefined` fields keep the `| undefined`), so the static
- * type matches what's actually returned at runtime.
- */
-type DeepPoseAugmented<T, Depth extends readonly unknown[] = []> = T extends unknown ? AugmentPosesCore<T, Depth> : never;
-/**
- * Recursively walks a parsed API response/request body, upgrading any
- * `Pose`-shaped objects in place to `Pose` instances so they gain math
- * methods (`multiply`, `inverse`, ...) while remaining JSON/wire-compatible.
- * Used by `augmentMath` for `nova.api.*` responses; exported so it can also
- * be applied manually to e.g. websocket messages.
- */
-declare function augmentPoses<T>(value: T): DeepPoseAugmented<T>;
-type WithAugmentedPosesCore<T, Depth extends readonly unknown[]> = Depth["length"] extends MaxDepth["length"] ? T : T extends ((...args: infer A) => Promise<infer R>) ? (...args: A) => Promise<DeepPoseAugmented<R>> : T extends object ? { [K in keyof T]: WithAugmentedPosesCore<T[K], [...Depth, unknown]>; } : T;
-/**
- * Recursively maps every method on `Nova["api"]` (and its nested API groups)
- * so calls are typed as returning `DeepPoseAugmented` results, matching what
- * `augmentMath` does at runtime.
- */
-type WithAugmentedPoses<T> = WithAugmentedPosesCore<T, []>;
-type NovaWithMath = Omit<Nova, "api"> & {
-  readonly api: WithAugmentedPoses<Nova["api"]>;
-};
-/**
- * Wraps a `Nova` instance so every `nova.api.*` call automatically upgrades
- * `Pose`-shaped fields in its response to `Pose` instances (with math
- * methods like `multiply`/`inverse`). Returns a new proxied view - does not
- * mutate the original `nova` instance.
- */
-declare function augmentMath(nova: Nova): NovaWithMath;
-//#endregion
 //#region src/lib/experimental/math/Quaternion.d.ts
 /**
- * Internal quaternion helpers used to compose/invert the axis-angle
- * `orientation` vectors used by the NOVA API's `Pose` type. Rotation vectors
- * are converted to quaternions for composition (numerically stable, unlike
- * composing axis-angle vectors directly) and converted back at the boundary.
+ * A unit quaternion representing a 3D rotation. Mirrors the subset of
+ * `Eigen::Quaternion`'s API (see wb-robotix's `QuaternionBasePlugin.h`) that
+ * `Pose` composition needs: Hamilton product, conjugate/inverse, vector
+ * rotation, and axis-angle rotation-vector conversion. Instances are
+ * immutable - every method returns a new `Quaternion`.
  */
-type Quaternion = {
+type QuaternionData = {
   w: number;
   x: number;
   y: number;
   z: number;
 };
-/** Convert an axis-angle rotation vector [rx, ry, rz] to a unit quaternion. */
-declare function axisAngleToQuaternion(r: number[]): Quaternion;
-/**
- * Convert a unit quaternion back to an axis-angle rotation vector [rx, ry, rz],
- * matching wb-robotix's `Quaternion::toRotationVector()` (ported from
- * QuaternionBasePlugin.h): using `atan2` rather than `acos` keeps the angle
- * canonically within [0, pi] regardless of which of the two antipodal unit
- * quaternions (q or -q) represents the rotation, rather than acos's [0, 2*pi]
- * range - important since composed poses need to match the same canonical
- * rotation vector the robot controller itself would report for a pose.
- */
-declare function quaternionToAxisAngle(q: Quaternion): number[];
-/** Hamilton product: composes rotations so that applying `multiplyQuaternions(a, b)` to a vector equals applying `b` then `a`. */
-declare function multiplyQuaternions(a: Quaternion, b: Quaternion): Quaternion;
-/** Conjugate of a unit quaternion equals its inverse. */
-declare function conjugateQuaternion(q: Quaternion): Quaternion;
-/** Rotate a 3D vector by a unit quaternion. */
-declare function rotateVectorByQuaternion(q: Quaternion, v: number[]): number[];
+declare class Quaternion implements QuaternionData {
+  readonly w: number;
+  readonly x: number;
+  readonly y: number;
+  readonly z: number;
+  constructor(w?: number, x?: number, y?: number, z?: number);
+  static identity(): Quaternion;
+  /**
+   * Construct from an axis-angle rotation vector [rx, ry, rz] (magnitude =
+   * angle in rad), matching `Eigen::Quaternion::FromRotationVector` (ported
+   * from wb-robotix's `QuaternionBasePlugin.h`).
+   */
+  static fromRotationVector(rotationVector: number[]): Quaternion;
+  /**
+   * Rotation vector [rx, ry, rz] representation (magnitude = angle in rad),
+   * matching `Eigen::Quaternion::toRotationVector()` (ported from
+   * wb-robotix's `QuaternionBasePlugin.h`): using `atan2` rather than `acos`
+   * keeps the angle canonically within [0, pi] regardless of which of the
+   * two antipodal unit quaternions (this or its negation) represents the
+   * rotation, rather than acos's [0, 2*pi] range - important since composed
+   * poses need to match the same canonical rotation vector the robot
+   * controller itself would report for a pose.
+   */
+  toRotationVector(): number[];
+  /** Hamilton product: `a.multiply(b)` applied to a vector rotates by `b` first, then by `a`. */
+  multiply(other: QuaternionData): Quaternion;
+  /** Conjugate: negates the vector part. Equal to `inverse()` for unit quaternions. */
+  conjugate(): Quaternion;
+  /** Inverse rotation. Equivalent to `conjugate()` since a `Pose`'s orientation is always a unit quaternion. */
+  inverse(): Quaternion;
+  /**
+   * The angle (in rad, always within [0, pi]) of the rotation that takes
+   * `other` to `this`, matching Eigen's built-in `Quaternion::angularDistance()`.
+   */
+  angularDistance(other: QuaternionData): number;
+  /** Rotate a 3D vector by this quaternion. */
+  rotateVector(v: number[]): number[];
+  toJSON(): QuaternionData;
+}
 //#endregion
-export { type DeepPoseAugmented, type NovaWithMath, Pose, type Pose$1 as PoseData, type Quaternion, augmentMath, augmentPoses, axisAngleToQuaternion, conjugateQuaternion, multiplyQuaternions, quaternionToAxisAngle, rotateVectorByQuaternion };
+export { Pose, type Pose$1 as PoseData, Quaternion, type QuaternionData };
 //# sourceMappingURL=index.d.mts.map

package/dist/experimental/math/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","names":[],"sources":["../../../src/lib/experimental/math/Pose.ts","../../../src/lib/experimental/math/augmentMath.ts","../../../src/lib/experimental/math/Quaternion.ts"],"mappings":";;;;;;;;;;;;;cAkCa,gBAAgB;WAClB;WACA;EAGP,YAAA,qBACA;SAMK,KAAK,MAAM,SAAW;SAUtB,YAAY;;;;;;;EAUnB,SAAS,OAAO,SAAW;;EAc3B,WAAW;;EAeX,eAAe;;EAMf,OAAO,OAAO,QAAU;EAcxB,UAAU;;;;KC/GP,iBAAiB;KAEjB,kBAAkB,MAAM,cAAc,GAAG,8BACzC,QAAQ,gBAAgB;KAOxB;KAaA,iBACH,GACA,oCACE,wBAAwB,qBACxB,IACA,kBAAkB,kBAChB,OACA,0BAA0B,OACxB,kBAAkB,OAAO,qBACzB,sBACK,WAAW,IAAI,kBAAkB,EAAE,QAAQ,sBAC9C;;;;;;;KAQE,kBACV,GACA,yCACE,oBAAoB,iBAAiB,GAAG;;;;;;;;iBA2D5B,aAAa,GAAG,OAAO,IAAI,kBAAkB;KAKxD,uBACH,GACA,oCACE,wBAAwB,qBACxB,IACA,eAAc,YAAY,MAAM,cAAc,UACxC,MAAM,MAAM,QAAQ,kBAAkB,MAC1C,sBACK,WAAW,IAAI,uBAAuB,EAAE,QAAQ,sBACnD;;;;;;KAOH,mBAAmB,KAAK,uBAAuB;KAExC,eAAe,KAAK;WACrB,KAAK,mBAAmB;;;;;;;;iBA6BnB,YAAY,MAAM,OAAO;;;;;;;;;KC1J7B;EAAe;EAAW;EAAW;EAAW;;;iBAK5C,sBAAsB,cAAc;;;;;;;;;;iBAuBpC,sBAAsB,GAAG;;iBAWzB,oBAAoB,GAAG,YAAY,GAAG,aAAa;;iBAUnD,oBAAoB,GAAG,aAAa;;iBAKpC,yBAAyB,GAAG,YAAY"}
+{"version":3,"file":"index.d.mts","names":[],"sources":["../../../src/lib/experimental/math/Pose.ts","../../../src/lib/experimental/math/Quaternion.ts"],"mappings":";;;;;;;;;cA+Ba,gBAAgB;WAClB;WACA;EAGP,YAAA,qBACA;SAkBK,KAAK,MAAM,SAAW;SAUtB,YAAY;;;;;;;EAUnB,SAAS,OAAO,SAAW;;EAc3B,WAAW;;EAWX,eAAe;;;;;;;;;EAaf,SACE,OAAO,QACP,wBACA;;;;;;EA0BF;;EAWA,SAAS;EAKT,UAAU;;;;;;;;;;;KCtJA;EAAmB;EAAW;EAAW;EAAW;;cAInD,sBAAsB;WACxB;WACA;WACA;WACA;EAEG,YAAA,YAAO,YAAO,YAAO;SAO1B,YAAY;;;;;;SASZ,mBAAmB,2BAA2B;;;;;;;;;;;EAwBrD;;EAaA,SAAS,OAAO,iBAAiB;;EAYjC,aAAa;;EAKb,WAAW;;;;;EAQX,gBAAgB,OAAO;;EAgBvB,aAAa;EAmBb,UAAU"}

package/dist/experimental/math/index.mjs

@@ -1,83 +1,111 @@
 //#region src/lib/experimental/math/Quaternion.ts
 const EPSILON = 1e-12;
-/** Convert an axis-angle rotation vector [rx, ry, rz] to a unit quaternion. */
-function axisAngleToQuaternion(r) {
-	const rx = r[0] ?? 0;
-	const ry = r[1] ?? 0;
-	const rz = r[2] ?? 0;
-	const angle = Math.sqrt(rx * rx + ry * ry + rz * rz);
-	if (angle < EPSILON) return {
-		w: 1,
-		x: 0,
-		y: 0,
-		z: 0
-	};
-	const half = angle / 2;
-	const s = Math.sin(half) / angle;
-	return {
-		w: Math.cos(half),
-		x: rx * s,
-		y: ry * s,
-		z: rz * s
-	};
-}
-/**
-* Convert a unit quaternion back to an axis-angle rotation vector [rx, ry, rz],
-* matching wb-robotix's `Quaternion::toRotationVector()` (ported from
-* QuaternionBasePlugin.h): using `atan2` rather than `acos` keeps the angle
-* canonically within [0, pi] regardless of which of the two antipodal unit
-* quaternions (q or -q) represents the rotation, rather than acos's [0, 2*pi]
-* range - important since composed poses need to match the same canonical
-* rotation vector the robot controller itself would report for a pose.
-*/
-function quaternionToAxisAngle(q) {
-	const vecNorm = Math.sqrt(q.x * q.x + q.y * q.y + q.z * q.z);
-	if (vecNorm < EPSILON) return [
-		0,
-		0,
-		0
-	];
-	const angle = 2 * Math.atan2(vecNorm, Math.abs(q.w));
-	const scale = (q.w >= 0 ? angle : -angle) / vecNorm;
-	return [
-		q.x * scale,
-		q.y * scale,
-		q.z * scale
-	];
-}
-/** Hamilton product: composes rotations so that applying `multiplyQuaternions(a, b)` to a vector equals applying `b` then `a`. */
-function multiplyQuaternions(a, b) {
-	return {
-		w: a.w * b.w - a.x * b.x - a.y * b.y - a.z * b.z,
-		x: a.w * b.x + a.x * b.w + a.y * b.z - a.z * b.y,
-		y: a.w * b.y - a.x * b.z + a.y * b.w + a.z * b.x,
-		z: a.w * b.z + a.x * b.y - a.y * b.x + a.z * b.w
-	};
-}
-/** Conjugate of a unit quaternion equals its inverse. */
-function conjugateQuaternion(q) {
-	return {
-		w: q.w,
-		x: -q.x,
-		y: -q.y,
-		z: -q.z
-	};
-}
-/** Rotate a 3D vector by a unit quaternion. */
-function rotateVectorByQuaternion(q, v) {
-	const vx = v[0] ?? 0;
-	const vy = v[1] ?? 0;
-	const vz = v[2] ?? 0;
-	const { w, x, y, z } = q;
-	const tx = 2 * (y * vz - z * vy);
-	const ty = 2 * (z * vx - x * vz);
-	const tz = 2 * (x * vy - y * vx);
-	return [
-		vx + w * tx + (y * tz - z * ty),
-		vy + w * ty + (z * tx - x * tz),
-		vz + w * tz + (x * ty - y * tx)
-	];
-}
+var Quaternion = class Quaternion {
+	w;
+	x;
+	y;
+	z;
+	constructor(w = 1, x = 0, y = 0, z = 0) {
+		this.w = w;
+		this.x = x;
+		this.y = y;
+		this.z = z;
+	}
+	static identity() {
+		return new Quaternion();
+	}
+	/**
+	* Construct from an axis-angle rotation vector [rx, ry, rz] (magnitude =
+	* angle in rad), matching `Eigen::Quaternion::FromRotationVector` (ported
+	* from wb-robotix's `QuaternionBasePlugin.h`).
+	*/
+	static fromRotationVector(rotationVector) {
+		const rx = rotationVector[0] ?? 0;
+		const ry = rotationVector[1] ?? 0;
+		const rz = rotationVector[2] ?? 0;
+		const angle = Math.sqrt(rx * rx + ry * ry + rz * rz);
+		if (angle < EPSILON) return Quaternion.identity();
+		const half = angle / 2;
+		const s = Math.sin(half) / angle;
+		return new Quaternion(Math.cos(half), rx * s, ry * s, rz * s);
+	}
+	/**
+	* Rotation vector [rx, ry, rz] representation (magnitude = angle in rad),
+	* matching `Eigen::Quaternion::toRotationVector()` (ported from
+	* wb-robotix's `QuaternionBasePlugin.h`): using `atan2` rather than `acos`
+	* keeps the angle canonically within [0, pi] regardless of which of the
+	* two antipodal unit quaternions (this or its negation) represents the
+	* rotation, rather than acos's [0, 2*pi] range - important since composed
+	* poses need to match the same canonical rotation vector the robot
+	* controller itself would report for a pose.
+	*/
+	toRotationVector() {
+		const vecNorm = Math.sqrt(this.x * this.x + this.y * this.y + this.z * this.z);
+		if (vecNorm < EPSILON) return [
+			0,
+			0,
+			0
+		];
+		const angle = 2 * Math.atan2(vecNorm, Math.abs(this.w));
+		const scale = (this.w >= 0 ? angle : -angle) / vecNorm;
+		return [
+			this.x * scale,
+			this.y * scale,
+			this.z * scale
+		];
+	}
+	/** Hamilton product: `a.multiply(b)` applied to a vector rotates by `b` first, then by `a`. */
+	multiply(other) {
+		const { w: aw, x: ax, y: ay, z: az } = this;
+		const { w: bw, x: bx, y: by, z: bz } = other;
+		return new Quaternion(aw * bw - ax * bx - ay * by - az * bz, aw * bx + ax * bw + ay * bz - az * by, aw * by - ax * bz + ay * bw + az * bx, aw * bz + ax * by - ay * bx + az * bw);
+	}
+	/** Conjugate: negates the vector part. Equal to `inverse()` for unit quaternions. */
+	conjugate() {
+		return new Quaternion(this.w, -this.x, -this.y, -this.z);
+	}
+	/** Inverse rotation. Equivalent to `conjugate()` since a `Pose`'s orientation is always a unit quaternion. */
+	inverse() {
+		return this.conjugate();
+	}
+	/**
+	* The angle (in rad, always within [0, pi]) of the rotation that takes
+	* `other` to `this`, matching Eigen's built-in `Quaternion::angularDistance()`.
+	*/
+	angularDistance(other) {
+		const relative = this.multiply({
+			w: other.w,
+			x: -other.x,
+			y: -other.y,
+			z: -other.z
+		});
+		const vecNorm = Math.sqrt(relative.x * relative.x + relative.y * relative.y + relative.z * relative.z);
+		return 2 * Math.atan2(vecNorm, Math.abs(relative.w));
+	}
+	/** Rotate a 3D vector by this quaternion. */
+	rotateVector(v) {
+		const vx = v[0] ?? 0;
+		const vy = v[1] ?? 0;
+		const vz = v[2] ?? 0;
+		const { w, x, y, z } = this;
+		const tx = 2 * (y * vz - z * vy);
+		const ty = 2 * (z * vx - x * vz);
+		const tz = 2 * (x * vy - y * vx);
+		return [
+			vx + w * tx + (y * tz - z * ty),
+			vy + w * ty + (z * tx - x * tz),
+			vz + w * tz + (x * ty - y * tx)
+		];
+	}
+	toJSON() {
+		return {
+			w: this.w,
+			x: this.x,
+			y: this.y,
+			z: this.z
+		};
+	}
+};
 //#endregion
 //#region src/lib/experimental/math/Pose.ts
 const ZERO_VECTOR = [
@@ -85,6 +113,7 @@ const ZERO_VECTOR = [
 	0,
 	0
 ];
+const TOLERANCE_MILLI = .001;
 function addVectors(a, b) {
 	return [
 		(a[0] ?? 0) + (b[0] ?? 0),
@@ -99,23 +128,24 @@ function negateVector(a) {
 		-(a[2] ?? 0)
 	];
 }
+function isFiniteVector3(v) {
+	return v.length === 3 && v.every((n) => Number.isFinite(n));
+}
 /**
 * A `Pose` (position + axis-angle orientation) with methods for composing
 * and inverting transforms. Instances are plain-data compatible with the
 * wire-format `PoseData` type (own `position`/`orientation` properties only,
 * no enumerable methods), so they can be passed directly back into API calls
 * that expect a pose.
-*
-* Poses returned from `NovaAPIClient`/`Nova` are automatically upgraded to
-* `Pose` instances; construct one directly only when you have a pose from
-* elsewhere (e.g. a websocket message).
 */
 var Pose = class Pose {
 	position;
 	orientation;
 	constructor(position = ZERO_VECTOR, orientation = ZERO_VECTOR) {
-		this.position = position;
-		this.orientation = orientation;
+		if (!isFiniteVector3(position)) throw new Error(`Pose constructor: position must be an array of 3 finite numbers, got ${JSON.stringify(position)}`);
+		if (!isFiniteVector3(orientation)) throw new Error(`Pose constructor: orientation must be an array of 3 finite numbers, got ${JSON.stringify(orientation)}`);
+		this.position = [...position];
+		this.orientation = [...orientation];
 	}
 	static from(pose) {
 		if (pose instanceof Pose) return pose;
@@ -131,28 +161,59 @@ var Pose = class Pose {
 	* applying `other` first, then `this`.
 	*/
 	multiply(other) {
-		const q1 = axisAngleToQuaternion(this.orientation);
-		const q2 = axisAngleToQuaternion(other.orientation ?? ZERO_VECTOR);
-		const position = addVectors(this.position, rotateVectorByQuaternion(q1, other.position ?? ZERO_VECTOR));
-		const orientation = quaternionToAxisAngle(multiplyQuaternions(q1, q2));
+		const q1 = Quaternion.fromRotationVector(this.orientation);
+		const q2 = Quaternion.fromRotationVector(other.orientation ?? ZERO_VECTOR);
+		const position = addVectors(this.position, q1.rotateVector(other.position ?? ZERO_VECTOR));
+		const orientation = q1.multiply(q2).toRotationVector();
 		return new Pose(position, orientation);
 	}
 	/** The inverse transform, such that `pose.multiply(pose.inverse())` is the identity pose. */
 	inverse() {
-		const position = rotateVectorByQuaternion(conjugateQuaternion(axisAngleToQuaternion(this.orientation)), negateVector(this.position));
+		const position = Quaternion.fromRotationVector(this.orientation).inverse().rotateVector(negateVector(this.position));
 		const orientation = negateVector(this.orientation);
 		return new Pose(position, orientation);
 	}
 	/** Apply this pose's transform to a point, returning the transformed point. */
 	transformPoint(point) {
-		const q = axisAngleToQuaternion(this.orientation);
-		return addVectors(this.position, rotateVectorByQuaternion(q, point));
+		const q = Quaternion.fromRotationVector(this.orientation);
+		return addVectors(this.position, q.rotateVector(point));
 	}
-	/** Compare to another pose within a tolerance, since floating-point pose math rarely produces exact equality. */
-	equals(other, epsilon = 1e-9) {
+	/**
+	* Compare to another pose using separate position/orientation tolerances,
+	* matching wb-robotix's `Pose::isApprox()`: Euclidean distance for
+	* position, and quaternion angular distance for orientation - not a naive
+	* per-component diff, since two rotation vectors can represent nearly
+	* identical rotations while differing componentwise near a
+	* canonicalization boundary (e.g. close to the +/-pi wraparound).
+	*/
+	isApprox(other, deltaPosition = TOLERANCE_MILLI, deltaOrientation = TOLERANCE_MILLI) {
 		const otherPosition = other.position ?? ZERO_VECTOR;
 		const otherOrientation = other.orientation ?? ZERO_VECTOR;
-		return this.position.every((v, i) => Math.abs(v - (otherPosition[i] ?? 0)) <= epsilon) && this.orientation.every((v, i) => Math.abs(v - (otherOrientation[i] ?? 0)) <= epsilon);
+		const positionDistance = Math.sqrt(this.position.reduce((sum, v, i) => sum + (v - (otherPosition[i] ?? 0)) ** 2, 0));
+		const orientationDistance = Quaternion.fromRotationVector(this.orientation).angularDistance(Quaternion.fromRotationVector(otherOrientation));
+		return positionDistance <= deltaPosition && orientationDistance <= deltaOrientation;
+	}
+	/**
+	* Position + orientation as a 6-element [x, y, z, roll, pitch, yaw] vector
+	* (Euler angles in rad, XYZ Tait-Bryan / Rx*Ry*Rz convention), matching
+	* wb-robotix's `Pose::toCartesian()`.
+	*/
+	toCartesian() {
+		const { w, x, y, z } = Quaternion.fromRotationVector(this.orientation);
+		const roll = Math.atan2(2 * (w * x - y * z), 1 - 2 * (x * x + y * y));
+		const pitch = Math.asin(Math.min(1, Math.max(-1, 2 * (x * z + w * y))));
+		const yaw = Math.atan2(2 * (w * z - x * y), 1 - 2 * (y * y + z * z));
+		return [
+			...this.position,
+			roll,
+			pitch,
+			yaw
+		];
+	}
+	/** Human-readable `[x, y, z][rx, ry, rz]` representation, matching wb-robotix's `Pose::string()`. */
+	toString(precision = 6) {
+		const fmt = (v) => Number(v.toPrecision(precision));
+		return `[${this.position.map(fmt).join(", ")}][${this.orientation.map(fmt).join(", ")}]`;
 	}
 	toJSON() {
 		return {
@@ -162,65 +223,6 @@ var Pose = class Pose {
 	}
 };
 //#endregion
-//#region src/lib/experimental/math/augmentMath.ts
-function isPlainObject(value) {
-	return typeof value === "object" && value !== null && !Array.isArray(value) && !(value instanceof Pose);
-}
-function isNumberTriple(value) {
-	return Array.isArray(value) && value.length === 3 && value.every((n) => typeof n === "number");
-}
-/**
-* Structural check for the wire shape of `Pose` (`{ position, orientation }`,
-* each a 3-number array, and nothing else). This API has no other type with
-* this exact shape, so it reliably identifies `Pose` values without needing
-* per-endpoint knowledge of which fields are poses.
-*/
-function isPoseShape(value) {
-	return Object.keys(value).length === 2 && isNumberTriple(value.position) && isNumberTriple(value.orientation);
-}
-function augmentPosesInPlace(value) {
-	if (Array.isArray(value)) {
-		for (const item of value) augmentPosesInPlace(item);
-		return;
-	}
-	if (isPlainObject(value)) if (isPoseShape(value)) Object.setPrototypeOf(value, Pose.prototype);
-	else for (const key of Object.keys(value)) augmentPosesInPlace(value[key]);
-}
-/**
-* Recursively walks a parsed API response/request body, upgrading any
-* `Pose`-shaped objects in place to `Pose` instances so they gain math
-* methods (`multiply`, `inverse`, ...) while remaining JSON/wire-compatible.
-* Used by `augmentMath` for `nova.api.*` responses; exported so it can also
-* be applied manually to e.g. websocket messages.
-*/
-function augmentPoses(value) {
-	augmentPosesInPlace(value);
-	return value;
-}
-function wrapWithPoseAugmentation(target) {
-	return new Proxy(target, { get(t, prop) {
-		const value = Reflect.get(t, prop, t);
-		if (typeof value === "function") return (...args) => {
-			const result = value.apply(t, args);
-			return result instanceof Promise ? result.then((data) => augmentPoses(data)) : result;
-		};
-		if (value !== null && typeof value === "object") return wrapWithPoseAugmentation(value);
-		return value;
-	} });
-}
-/**
-* Wraps a `Nova` instance so every `nova.api.*` call automatically upgrades
-* `Pose`-shaped fields in its response to `Pose` instances (with math
-* methods like `multiply`/`inverse`). Returns a new proxied view - does not
-* mutate the original `nova` instance.
-*/
-function augmentMath(nova) {
-	return new Proxy(nova, { get(target, prop) {
-		if (prop === "api") return wrapWithPoseAugmentation(target.api);
-		return Reflect.get(target, prop, target);
-	} });
-}
-//#endregion
-export { Pose, augmentMath, augmentPoses, axisAngleToQuaternion, conjugateQuaternion, multiplyQuaternions, quaternionToAxisAngle, rotateVectorByQuaternion };
+export { Pose, Quaternion };
 
 //# sourceMappingURL=index.mjs.map