@dronedeploy/rocos-js-sdk 4.1.1 → 4.3.0-rc.1

package/esm/models/RocosError.js

@@ -28,6 +28,7 @@ export const errorCodes = {
     TARGET_SERVICE_ERROR: 'TARGET_SERVICE_ERROR',
     ENVIRONMENT_SERVICE_ERROR: 'ENVIRONMENT_SERVICE_ERROR',
     TAG_SERVICE_ERROR: 'TAG_SERVICE_ERROR',
+    ROBOT_STATUS_SERVICE_ERROR: 'ROBOT_STATUS_SERVICE_ERROR',
 };
 export class RocosError extends Error {
     constructor(err, code, statusCode) {

package/esm/models/ServiceEnum.d.ts

@@ -17,6 +17,7 @@ export declare enum ServiceEnum {
     PROJECT = "project",
     PROFILE = "profile",
     ROBOT = "robot",
+    ROBOT_STATUS = "robot_status",
     RTP_WEBRTC = "rtp_webrtc",
     SCHEDULE = "schedule",
     SEARCH = "search",

package/esm/models/ServiceEnum.js

@@ -18,6 +18,7 @@ export var ServiceEnum;
     ServiceEnum["PROJECT"] = "project";
     ServiceEnum["PROFILE"] = "profile";
     ServiceEnum["ROBOT"] = "robot";
+    ServiceEnum["ROBOT_STATUS"] = "robot_status";
     ServiceEnum["RTP_WEBRTC"] = "rtp_webrtc";
     ServiceEnum["SCHEDULE"] = "schedule";
     ServiceEnum["SEARCH"] = "search";

package/esm/models/index.d.ts

@@ -51,6 +51,7 @@ export * from './maps/Map';
 export * from './maps/MapContent';
 export * from './maps/MapEdge';
 export * from './maps/MapNode';
+export * from './maps/MapPath';
 export * from './maps/Panorama';
 export * from './message';
 export * from './params/ICallerParams';

package/esm/models/index.js

@@ -51,6 +51,7 @@ export * from './maps/Map';
 export * from './maps/MapContent';
 export * from './maps/MapEdge';
 export * from './maps/MapNode';
+export * from './maps/MapPath';
 export * from './maps/Panorama';
 export * from './message';
 export * from './params/ICallerParams';

package/esm/models/maps/MapPath.d.ts

@@ -0,0 +1,143 @@
+import { Quaternion, Vector3 } from '../graph';
+import { MapContentNode } from './MapContent';
+/**
+ * A path (polyline or polygon) in a robot map, as returned by
+ * `GET /graphs/projects/{projectId}/maps/{mapId}/paths/{pathId}` — the same shape the
+ * rocos-agent map component's `paths/get` service reports.
+ *
+ * A path is stored as a sub-graph following the `go-common/graph/paths` convention: a parent
+ * node (type `path.parent.v1`, or any existing node acting as anchor) plus one member node
+ * per vertex, wired by `path.start.v1` / `path.belongs.v1` / `path.edge.v1` edges. The path
+ * id IS the parent node id.
+ */
+export interface MapPath {
+    /** The path id (= parent node id). */
+    id: string;
+    /** Whether the path is a closed polygon (true) or an open polyline (false). */
+    closed: boolean;
+    /** The full parent node. */
+    parent: MapContentNode;
+    /** Ordered member (vertex) node ids, walked start → end. */
+    members: string[];
+}
+/** Filters for `MapService.listPaths`. */
+export interface ListPathsFilter {
+    /** Only include paths with this closed flag (omit for both). */
+    closed?: boolean;
+    /**
+     * Only include paths whose parent node type is in this list (omit for all).
+     *
+     * Wire-format caveat: the server takes this as a single comma-separated query parameter
+     * (`?types=a,b`), so a node type that itself contains a comma cannot be expressed — it
+     * would be split into two wrong filter terms and silently match nothing. Node types are
+     * free-form text server-side, so this is conceivable if unlikely; avoid commas in type
+     * names, or filter client-side over `listPaths` + `getPath` results if you must.
+     */
+    types?: string[];
+}
+/**
+ * Body of `POST /graphs/projects/{projectId}/maps/{mapId}/paths/{pathId}/append`. Appends
+ * already-existing member nodes to a path, creating the path (and its `path.parent.v1`
+ * parent node) when absent — an existing node of any client-writable type is reused as the
+ * anchor instead.
+ *
+ * Members must already exist in the map (400 otherwise). `closed` is only applied while the
+ * path is empty; supplying a value that conflicts with a non-empty path's stored flag is
+ * rejected with 409 (use {@link MapService.replacePath} to change closed-ness). `data` keys
+ * are merged onto the parent node.
+ */
+export interface AppendToPathRequest {
+    closed?: boolean;
+    data?: Record<string, unknown>;
+    members: string[];
+}
+/**
+ * A rigid-body transform positioning one path vertex relative to the frame named in the
+ * enclosing request. `rot` is optional and defaults to identity — path vertices are
+ * typically plain positions. Field naming matches {@link AffineTransform} (`pos`/`rot`);
+ * the service marshals onto the server's `translation`/`rotation` wire shape.
+ */
+export interface PathPointTransform {
+    rot?: Quaternion;
+    pos: Vector3;
+}
+/**
+ * One vertex in a path payload. `id` is optional; when blank the server mints a UUID.
+ *
+ * `transform` is required by the append endpoint (which only creates vertices). In a path
+ * replace its presence carries the intent: supplied means the position is declarative (the
+ * vertex is created or — when the path exclusively owns the node — recreated at that
+ * position, which is how vertices are moved), while omitted means "reuse the existing node
+ * in place, position untouched".
+ */
+export interface PathPoint {
+    id?: string;
+    data?: Record<string, unknown>;
+    transform?: PathPointTransform;
+}
+/**
+ * A {@link PathPoint} whose transform is mandatory, for the append/transformable body —
+ * that endpoint only creates vertices, so every point needs a position. Requiring it at the
+ * type level moves the server's 400 for a transform-less point to compile time.
+ */
+export interface TransformablePathPoint extends PathPoint {
+    transform: PathPointTransform;
+}
+/**
+ * Body of `POST /graphs/projects/{projectId}/maps/{mapId}/paths/{pathId}/append/transformable`.
+ * For each point it creates a node (`nodeType`, default `FRAME`) positioned by a `TRANSFORM`
+ * edge from the existing `frame` node, and appends them all to the path in one transaction —
+ * the cloud analog of the rocos-agent's `paths/append/currentPosition`, with the caller
+ * supplying positions instead of the robot's live pose.
+ *
+ * Every point must carry a `transform` (enforced by {@link TransformablePathPoint}; the
+ * server also rejects a transform-less point with 400 — append only creates vertices; use
+ * {@link MapService.appendToPath} to append existing nodes). Node creation is create-only: a
+ * point id that already exists in the map is rejected with 409 and the whole append rolls
+ * back. `closed` and `data` behave as in {@link AppendToPathRequest}.
+ */
+export interface AppendTransformablePointsRequest {
+    closed?: boolean;
+    data?: Record<string, unknown>;
+    frame: string;
+    nodeType?: string;
+    points: TransformablePathPoint[];
+}
+/** Response of the append/transformable endpoint: the created vertex ids, in path order. */
+export interface AppendPathPointsResponse {
+    ids: string[];
+}
+/**
+ * Body of `PUT /graphs/projects/{projectId}/maps/{mapId}/paths/{pathId}` — the editor
+ * primitive. Declares the path's entire desired state; vertex move/insert/delete/reorder
+ * and closed-flag changes all reach the server as one idempotent call.
+ *
+ * The existing structure is torn down (old vertices exclusively owned by the path are
+ * deleted; shared members are detached, never moved or deleted; the parent node always
+ * survives) and rebuilt from `points`. Each point's `transform` carries its intent:
+ *
+ * - **With a transform** the position is declarative: the vertex is created (as `nodeType`,
+ *   default `FRAME`, positioned by a `TRANSFORM` edge from `frame`), and for the path's own
+ *   vertices same id + new transform = a move. A transform on a node the path doesn't
+ *   exclusively own is rejected with 409.
+ * - **Without a transform** the point reuses an existing node in place, position untouched
+ *   (400 if it doesn't exist) — how shared waypoints stay in the path.
+ *
+ * `parentType` applies when the parent node is created (default `path.parent.v1`); against
+ * an existing parent it must match (409) or be omitted (reused as-is, the anchored-path
+ * model). Replacing can also repair a structurally malformed path (which `getPath` reports
+ * as 422). Repeated identical PUTs are hash-stable: the server skips the map-timestamp bump
+ * and SUMMARY rewrite when the result matches what is stored.
+ *
+ * Access rules match {@link MapService.deletePath} (replace deletes vertices): the
+ * environment map is off-limits, the dronedeploy map is admin-only, normal maps are open to
+ * any caller with project access.
+ */
+export interface ReplacePathRequest {
+    closed: boolean;
+    parentType?: string;
+    nodeType?: string;
+    data?: Record<string, unknown>;
+    frame?: string;
+    points: PathPoint[];
+}

package/esm/models/maps/MapPath.js

@@ -0,0 +1 @@
+export {};

package/esm/models/robot-status/RobotStatusEnums.d.ts

@@ -45,7 +45,7 @@ export declare enum ServiceConnection {
  * expected services.
  */
 export declare enum RobotConnectivity {
-    /** Every expected service reports connected. */
+    /** At least one expected service is connected and none is disconnected. */
     ONLINE = "online",
     /** Some, but not all, expected services report connected. */
     DEGRADED = "degraded",

package/esm/models/robot-status/RobotStatusEnums.js

@@ -49,7 +49,7 @@ export var ServiceConnection;
  */
 export var RobotConnectivity;
 (function (RobotConnectivity) {
-    /** Every expected service reports connected. */
+    /** At least one expected service is connected and none is disconnected. */
     RobotConnectivity["ONLINE"] = "online";
     /** Some, but not all, expected services report connected. */
     RobotConnectivity["DEGRADED"] = "degraded";

package/esm/services/MapService.d.ts

@@ -1,6 +1,7 @@
 import { AddEdgeRequest, AddEdgeResponse, AddTransformEdgeRequest } from '../models/maps/MapEdge';
 import { AddNodeRequest, AddNodeResponse, AddTransformableNodeRequest } from '../models/maps/MapNode';
 import { AddPanoramaRequest, AddPanoramaResponse, CreateObservation, Observation } from '../models/maps/Panorama';
+import { AppendPathPointsResponse, AppendToPathRequest, AppendTransformablePointsRequest, ListPathsFilter, MapPath, ReplacePathRequest } from '../models/maps/MapPath';
 import { Asset, IBaseService, IRocosSDKConfig, Map, MapContent, RocosError } from '../models';
 import { BaseServiceAbstract } from './BaseServiceAbstract';
 /**
@@ -334,4 +335,104 @@ export declare class MapService extends BaseServiceAbstract implements IBaseServ
      * @param edgeId The ID of the edge to delete.
      */
     deleteEdge(projectId: string, mapId: string, edgeId: string): Promise<void>;
+    /**
+     * List the paths (polylines/polygons) in a map. A path is a sub-graph following the
+     * `go-common/graph/paths` convention shared with the rocos-agent's map component; this
+     * mirrors the agent's `paths/list` service, returning the parent node ids of every path
+     * that survives the filters.
+     *
+     * @param projectId The ID of the project the map belongs to.
+     * @param mapId The ID of the map to list paths from.
+     * @param filter Optional closed-flag and parent-node-type filters. The type filter goes
+     * over the wire as one comma-separated query parameter, so types containing a comma
+     * cannot be expressed (see {@link ListPathsFilter.types}).
+     * @returns The path ids (= parent node ids), sorted.
+     */
+    listPaths(projectId: string, mapId: string, filter?: ListPathsFilter): Promise<string[]>;
+    /**
+     * Get one path: its closed flag, full parent node, and ordered member node ids — the same
+     * shape as the agent's `paths/get` response. An existing node with no path structure is
+     * reported as an empty open path; a missing node is 404; stored structure violating the
+     * path convention (e.g. multiple start edges) is 422 (repair it with {@link replacePath}).
+     *
+     * @param projectId The ID of the project the map belongs to.
+     * @param mapId The ID of the map the path lives in.
+     * @param pathId The path id (= parent node id).
+     */
+    getPath(projectId: string, mapId: string, pathId: string): Promise<MapPath>;
+    /**
+     * Append already-existing member nodes to a path, creating the path when absent —
+     * mirroring the agent's `paths/append`. Members must already exist (400 otherwise);
+     * `path.index` numbering continues from the existing member count. A `closed` value
+     * conflicting with a non-empty path's stored flag is rejected with 409 (unlike the agent,
+     * which silently ignores it) — change closed-ness with {@link replacePath}.
+     *
+     * @param projectId The ID of the project the map belongs to.
+     * @param mapId The ID of the map the path lives in.
+     * @param pathId The path id (= parent node id).
+     * @param body The members to append, plus optional closed flag and parent data.
+     */
+    appendToPath(projectId: string, mapId: string, pathId: string, body: AppendToPathRequest): Promise<void>;
+    /**
+     * Create one positioned vertex node per point and append them all to a path in one
+     * transaction — the cloud analog of the agent's `paths/append/currentPosition`, with the
+     * caller supplying positions instead of the robot's live pose. Every point must carry a
+     * transform (append only creates; use {@link appendToPath} for existing nodes); a point id
+     * that already exists is a 409 and the whole append rolls back.
+     *
+     * Wire-shape note: the server receives each point's transform as
+     * `{ rotation, translation }`. This method marshals the caller-facing `rot`/`pos`
+     * (matching the node/panorama transform naming) onto that shape before POSTing.
+     *
+     * @param projectId The ID of the project the map belongs to.
+     * @param mapId The ID of the map the path lives in.
+     * @param pathId The path id (= parent node id).
+     * @param body The frame, points, and optional node type / closed flag / parent data.
+     * @returns The created vertex node ids, in path order (server-minted UUIDs for blank ids).
+     */
+    appendTransformablePointsToPath(projectId: string, mapId: string, pathId: string, body: AppendTransformablePointsRequest): Promise<AppendPathPointsResponse>;
+    /**
+     * Replace a path's entire structure in one idempotent call — the editor primitive for
+     * vertex move/insert/delete/reorder and closed-flag changes. See {@link ReplacePathRequest}
+     * for the full semantics; the essentials:
+     *
+     * - A point WITH a transform declares its position; for the path's own vertices, same id +
+     *   new transform = a move. A transform on a node the path doesn't exclusively own is 409.
+     * - A point WITHOUT a transform reuses an existing node in place (400 if missing).
+     * - Old vertices exclusively owned by the path and not re-referenced are deleted; shared
+     *   members are detached, never moved or deleted.
+     * - `parentType` must match an existing parent (409) or be omitted; it applies on create.
+     *
+     * @param projectId The ID of the project the map belongs to.
+     * @param mapId The ID of the map the path lives in.
+     * @param pathId The path id (= parent node id).
+     * @param body The path's desired state.
+     */
+    replacePath(projectId: string, mapId: string, pathId: string, body: ReplacePathRequest): Promise<void>;
+    /**
+     * Delete a path's structure, mirroring the agent's `paths/delete`: idempotent (a missing
+     * path still returns success), member nodes preserved by default, and the parent node
+     * itself deleted only when it is a pure `path.parent.v1` (an anchored path keeps its
+     * anchor node, minus the path edges).
+     *
+     * With `deleteMembers`, member nodes exclusively owned by the path (no remaining edges
+     * beyond their positioning `TRANSFORM`) are also removed; anything referenced elsewhere
+     * survives. Access rules match {@link deleteNode}: environment off-limits, dronedeploy
+     * admin-only, normal maps open to any caller with project access.
+     *
+     * @param projectId The ID of the project the map belongs to.
+     * @param mapId The ID of the map the path lives in.
+     * @param pathId The path id (= parent node id).
+     * @param opts Set `deleteMembers` to also remove exclusively-owned vertex nodes.
+     */
+    deletePath(projectId: string, mapId: string, pathId: string, opts?: {
+        deleteMembers?: boolean;
+    }): Promise<void>;
+    /**
+     * Marshal a caller-facing {@link PathPoint} onto the server's wire shape: `rot`/`pos`
+     * become `rotation`/`translation`, and an absent transform stays absent (its presence
+     * carries intent in a replace). A missing `rot` is left for the server to default to
+     * identity.
+     */
+    private pathPointToWire;
 }

package/esm/services/MapService.js

@@ -1,4 +1,4 @@
-import { API_GRAPHS_MAPS_COPY_URL, API_GRAPHS_MAPS_DEPLOYED_URL, API_GRAPHS_MAPS_DEPLOY_URL, API_GRAPHS_MAPS_GEOJSON_URL, API_GRAPHS_MAPS_MERGE_URL, API_GRAPHS_MAPS_NEW_URL, API_GRAPHS_MAPS_URL, API_GRAPHS_MAP_CONTENT_URL, API_GRAPHS_MAP_EDGES_ADD_TRANSFORM_URL, API_GRAPHS_MAP_EDGES_ADD_URL, API_GRAPHS_MAP_EDGE_URL, API_GRAPHS_MAP_ID_URL, API_GRAPHS_MAP_METADATA_URL, API_GRAPHS_MAP_NODES_ADD_TRANSFORMABLE_URL, API_GRAPHS_MAP_NODES_ADD_URL, API_GRAPHS_MAP_NODE_URL, API_GRAPHS_OBSERVATIONS_URL, API_GRAPHS_OBSERVATION_KEYS_URL, API_GRAPHS_PANORAMA, API_GRAPHS_PANORAMAS_URL, API_GRAPHS_PANORAMA_OBSERVATIONS_URL, } from '../constants/api';
+import { API_GRAPHS_MAPS_COPY_URL, API_GRAPHS_MAPS_DEPLOYED_URL, API_GRAPHS_MAPS_DEPLOY_URL, API_GRAPHS_MAPS_GEOJSON_URL, API_GRAPHS_MAPS_MERGE_URL, API_GRAPHS_MAPS_NEW_URL, API_GRAPHS_MAPS_URL, API_GRAPHS_MAP_CONTENT_URL, API_GRAPHS_MAP_EDGES_ADD_TRANSFORM_URL, API_GRAPHS_MAP_EDGES_ADD_URL, API_GRAPHS_MAP_EDGE_URL, API_GRAPHS_MAP_ID_URL, API_GRAPHS_MAP_METADATA_URL, API_GRAPHS_MAP_NODES_ADD_TRANSFORMABLE_URL, API_GRAPHS_MAP_NODES_ADD_URL, API_GRAPHS_MAP_NODE_URL, API_GRAPHS_MAP_PATHS_URL, API_GRAPHS_MAP_PATH_APPEND_TRANSFORMABLE_URL, API_GRAPHS_MAP_PATH_APPEND_URL, API_GRAPHS_MAP_PATH_URL, API_GRAPHS_OBSERVATIONS_URL, API_GRAPHS_OBSERVATION_KEYS_URL, API_GRAPHS_PANORAMA, API_GRAPHS_PANORAMAS_URL, API_GRAPHS_PANORAMA_OBSERVATIONS_URL, } from '../constants/api';
 import { RocosError, errorCodes } from '../models';
 import { BaseServiceAbstract } from './BaseServiceAbstract';
 import { RocosLogger } from '../logger/RocosLogger';
@@ -451,4 +451,144 @@ export class MapService extends BaseServiceAbstract {
     deleteEdge(projectId, mapId, edgeId) {
         return this.callDelete(formatServiceUrl(API_GRAPHS_MAP_EDGE_URL, { url: this.config.url, projectId, mapId, edgeId }, this.config.insecure), 'Failed to delete edge.');
     }
+    /**
+     * List the paths (polylines/polygons) in a map. A path is a sub-graph following the
+     * `go-common/graph/paths` convention shared with the rocos-agent's map component; this
+     * mirrors the agent's `paths/list` service, returning the parent node ids of every path
+     * that survives the filters.
+     *
+     * @param projectId The ID of the project the map belongs to.
+     * @param mapId The ID of the map to list paths from.
+     * @param filter Optional closed-flag and parent-node-type filters. The type filter goes
+     * over the wire as one comma-separated query parameter, so types containing a comma
+     * cannot be expressed (see {@link ListPathsFilter.types}).
+     * @returns The path ids (= parent node ids), sorted.
+     */
+    async listPaths(projectId, mapId, filter) {
+        const queryParams = {};
+        if (filter?.closed !== undefined)
+            queryParams.closed = filter.closed.toString();
+        if (filter?.types?.length)
+            queryParams.types = filter.types.join(',');
+        const resp = await this.callGet(formatServiceUrl(API_GRAPHS_MAP_PATHS_URL, { url: this.config.url, projectId, mapId }, this.config.insecure), 'Failed to list paths.', queryParams);
+        return resp.paths;
+    }
+    /**
+     * Get one path: its closed flag, full parent node, and ordered member node ids — the same
+     * shape as the agent's `paths/get` response. An existing node with no path structure is
+     * reported as an empty open path; a missing node is 404; stored structure violating the
+     * path convention (e.g. multiple start edges) is 422 (repair it with {@link replacePath}).
+     *
+     * @param projectId The ID of the project the map belongs to.
+     * @param mapId The ID of the map the path lives in.
+     * @param pathId The path id (= parent node id).
+     */
+    getPath(projectId, mapId, pathId) {
+        return this.callGet(formatServiceUrl(API_GRAPHS_MAP_PATH_URL, { url: this.config.url, projectId, mapId, pathId }, this.config.insecure), 'Failed to get path.');
+    }
+    /**
+     * Append already-existing member nodes to a path, creating the path when absent —
+     * mirroring the agent's `paths/append`. Members must already exist (400 otherwise);
+     * `path.index` numbering continues from the existing member count. A `closed` value
+     * conflicting with a non-empty path's stored flag is rejected with 409 (unlike the agent,
+     * which silently ignores it) — change closed-ness with {@link replacePath}.
+     *
+     * @param projectId The ID of the project the map belongs to.
+     * @param mapId The ID of the map the path lives in.
+     * @param pathId The path id (= parent node id).
+     * @param body The members to append, plus optional closed flag and parent data.
+     */
+    async appendToPath(projectId, mapId, pathId, body) {
+        await this.callPost(formatServiceUrl(API_GRAPHS_MAP_PATH_APPEND_URL, { url: this.config.url, projectId, mapId, pathId }, this.config.insecure), body, 'Failed to append to path.');
+    }
+    /**
+     * Create one positioned vertex node per point and append them all to a path in one
+     * transaction — the cloud analog of the agent's `paths/append/currentPosition`, with the
+     * caller supplying positions instead of the robot's live pose. Every point must carry a
+     * transform (append only creates; use {@link appendToPath} for existing nodes); a point id
+     * that already exists is a 409 and the whole append rolls back.
+     *
+     * Wire-shape note: the server receives each point's transform as
+     * `{ rotation, translation }`. This method marshals the caller-facing `rot`/`pos`
+     * (matching the node/panorama transform naming) onto that shape before POSTing.
+     *
+     * @param projectId The ID of the project the map belongs to.
+     * @param mapId The ID of the map the path lives in.
+     * @param pathId The path id (= parent node id).
+     * @param body The frame, points, and optional node type / closed flag / parent data.
+     * @returns The created vertex node ids, in path order (server-minted UUIDs for blank ids).
+     */
+    appendTransformablePointsToPath(projectId, mapId, pathId, body) {
+        const wireBody = {
+            closed: body.closed,
+            data: body.data,
+            frame: body.frame,
+            nodeType: body.nodeType,
+            points: body.points.map((p) => this.pathPointToWire(p)),
+        };
+        return this.callPost(formatServiceUrl(API_GRAPHS_MAP_PATH_APPEND_TRANSFORMABLE_URL, { url: this.config.url, projectId, mapId, pathId }, this.config.insecure), wireBody, 'Failed to append points to path.');
+    }
+    /**
+     * Replace a path's entire structure in one idempotent call — the editor primitive for
+     * vertex move/insert/delete/reorder and closed-flag changes. See {@link ReplacePathRequest}
+     * for the full semantics; the essentials:
+     *
+     * - A point WITH a transform declares its position; for the path's own vertices, same id +
+     *   new transform = a move. A transform on a node the path doesn't exclusively own is 409.
+     * - A point WITHOUT a transform reuses an existing node in place (400 if missing).
+     * - Old vertices exclusively owned by the path and not re-referenced are deleted; shared
+     *   members are detached, never moved or deleted.
+     * - `parentType` must match an existing parent (409) or be omitted; it applies on create.
+     *
+     * @param projectId The ID of the project the map belongs to.
+     * @param mapId The ID of the map the path lives in.
+     * @param pathId The path id (= parent node id).
+     * @param body The path's desired state.
+     */
+    async replacePath(projectId, mapId, pathId, body) {
+        const wireBody = {
+            closed: body.closed,
+            parentType: body.parentType,
+            nodeType: body.nodeType,
+            data: body.data,
+            frame: body.frame,
+            points: body.points.map((p) => this.pathPointToWire(p)),
+        };
+        await this.callPut(formatServiceUrl(API_GRAPHS_MAP_PATH_URL, { url: this.config.url, projectId, mapId, pathId }, this.config.insecure), wireBody, 'Failed to replace path.');
+    }
+    /**
+     * Delete a path's structure, mirroring the agent's `paths/delete`: idempotent (a missing
+     * path still returns success), member nodes preserved by default, and the parent node
+     * itself deleted only when it is a pure `path.parent.v1` (an anchored path keeps its
+     * anchor node, minus the path edges).
+     *
+     * With `deleteMembers`, member nodes exclusively owned by the path (no remaining edges
+     * beyond their positioning `TRANSFORM`) are also removed; anything referenced elsewhere
+     * survives. Access rules match {@link deleteNode}: environment off-limits, dronedeploy
+     * admin-only, normal maps open to any caller with project access.
+     *
+     * @param projectId The ID of the project the map belongs to.
+     * @param mapId The ID of the map the path lives in.
+     * @param pathId The path id (= parent node id).
+     * @param opts Set `deleteMembers` to also remove exclusively-owned vertex nodes.
+     */
+    deletePath(projectId, mapId, pathId, opts) {
+        let url = formatServiceUrl(API_GRAPHS_MAP_PATH_URL, { url: this.config.url, projectId, mapId, pathId }, this.config.insecure);
+        if (opts?.deleteMembers)
+            url += '?deleteMembers=true';
+        return this.callDelete(url, 'Failed to delete path.');
+    }
+    /**
+     * Marshal a caller-facing {@link PathPoint} onto the server's wire shape: `rot`/`pos`
+     * become `rotation`/`translation`, and an absent transform stays absent (its presence
+     * carries intent in a replace). A missing `rot` is left for the server to default to
+     * identity.
+     */
+    pathPointToWire(p) {
+        return {
+            id: p.id,
+            data: p.data,
+            transform: p.transform ? { rotation: p.transform.rot, translation: p.transform.pos } : undefined,
+        };
+    }
 }

package/esm/services/RobotStatusService.d.ts

@@ -0,0 +1,37 @@
+import { IBaseService, IRocosSDKConfig, RobotConnectivityStatus, RobotStatus, RocosError } from '../models';
+import { Observable } from 'rxjs';
+import { ReportedRobotStatus } from './robot-status/reportedStatus';
+import { BaseServiceAbstract } from './BaseServiceAbstract';
+/** Per-call tuning for the robot status observables. */
+export interface RobotStatusOptions {
+    /** Services whose connectivity gates ONLINE/DEGRADED. Defaults to the standard expected-services set. */
+    expectedServices?: string[];
+    /** How long without a heartbeat before telemetry-liveness is considered dead (ms). */
+    heartbeatTimeoutMs?: number;
+    /** How often the connections endpoints are polled (ms, floored internally). */
+    connectivityPollMs?: number;
+}
+/**
+ * The single source of truth for a robot's status. It composes the reported
+ * status (health/readiness from the heartbeat), per-service connectivity, and
+ * the canonical indicator colour, so consumers subscribe to one observable
+ * rather than deriving "is the robot online" themselves.
+ */
+export declare class RobotStatusService extends BaseServiceAbstract implements IBaseService {
+    constructor(config: IRocosSDKConfig);
+    getStatus(): boolean;
+    /** Health + readiness as reported by the robot (new topic, legacy heartbeat fallback). */
+    getReportedStatusChanges(projectId: string, callsign: string): Observable<ReportedRobotStatus>;
+    /** Per-service connectivity plus the aggregate verdict, polled. */
+    getConnectivityChanges(projectId: string, callsign: string, opts?: RobotStatusOptions): Observable<RobotConnectivityStatus>;
+    /** One-shot connectivity snapshot: resolves once every expected service is known, or after a timeout. */
+    getConnectivity(projectId: string, callsign: string, opts?: RobotStatusOptions): Promise<RobotConnectivityStatus>;
+    /**
+     * The headline stream: the combined {@link RobotStatus} including the canonical
+     * colour token. This is what status indicators subscribe to.
+     */
+    getRobotStatusChanges(projectId: string, callsign: string, opts?: RobotStatusOptions): Observable<RobotStatus>;
+    protected getError(e: Error): RocosError;
+    private get telemetryService();
+    private connectivityDeps;
+}

package/esm/services/RobotStatusService.js

@@ -0,0 +1,90 @@
+import { getConnectivityChanges } from './robot-status/connectivity';
+import { RobotHealth, RobotReadiness, RocosError, ServiceConnection, errorCodes, } from '../models';
+import { combineLatest, distinctUntilChanged, first, firstValueFrom, map, of, shareReplay, startWith, take, tap, timeout, } from 'rxjs';
+import { getReportedStatusChanges, getTelemetryLiveness } from './robot-status/reportedStatus';
+import { BaseServiceAbstract } from './BaseServiceAbstract';
+import { RocosLogger } from '../logger/RocosLogger';
+import { RocosStore } from '../store/RocosStore';
+import { getRobotStatusColour } from '../helpers/getRobotStatusColour';
+/** Upper bound on how long the one-shot {@link RobotStatusService.getConnectivity} waits to settle. */
+const ONE_SHOT_TIMEOUT_MS = 10000;
+const isKnown = (status) => {
+    return Object.values(status.services).every((connection) => connection !== ServiceConnection.UNKNOWN);
+};
+const robotStatusEquals = (a, b) => {
+    if (a.health !== b.health || a.readiness !== b.readiness)
+        return false;
+    if (a.connectivity.overall !== b.connectivity.overall)
+        return false;
+    const keys = Object.keys(a.connectivity.services);
+    if (keys.length !== Object.keys(b.connectivity.services).length)
+        return false;
+    return keys.every((key) => a.connectivity.services[key] === b.connectivity.services[key]);
+};
+/**
+ * The single source of truth for a robot's status. It composes the reported
+ * status (health/readiness from the heartbeat), per-service connectivity, and
+ * the canonical indicator colour, so consumers subscribe to one observable
+ * rather than deriving "is the robot online" themselves.
+ */
+export class RobotStatusService extends BaseServiceAbstract {
+    constructor(config) {
+        super(config);
+        this.logger = RocosLogger.getInstance(`RobotStatusService(${this.config.url})`);
+    }
+    getStatus() {
+        return true;
+    }
+    /** Health + readiness as reported by the robot (new topic, legacy heartbeat fallback). */
+    getReportedStatusChanges(projectId, callsign) {
+        return getReportedStatusChanges(this.telemetryService, projectId, callsign);
+    }
+    /** Per-service connectivity plus the aggregate verdict, polled. */
+    getConnectivityChanges(projectId, callsign, opts) {
+        return getConnectivityChanges(this.connectivityDeps(projectId, callsign, opts), projectId, callsign, opts?.expectedServices, opts?.connectivityPollMs);
+    }
+    /** One-shot connectivity snapshot: resolves once every expected service is known, or after a timeout. */
+    getConnectivity(projectId, callsign, opts) {
+        // Capture the latest snapshot explicitly: on timeout, refCount teardown would otherwise
+        // hand a fresh (all-UNKNOWN seed) re-subscription to the fallback rather than the last value.
+        let latest;
+        const changes$ = this.getConnectivityChanges(projectId, callsign, opts).pipe(tap((status) => {
+            latest = status;
+        }), shareReplay({ bufferSize: 1, refCount: true }));
+        return firstValueFrom(changes$.pipe(first(isKnown), 
+        // Don't wait forever on a persistently-unknown service — fall back to the latest snapshot seen.
+        timeout({ first: ONE_SHOT_TIMEOUT_MS, with: () => (latest ? of(latest) : changes$.pipe(take(1))) })));
+    }
+    /**
+     * The headline stream: the combined {@link RobotStatus} including the canonical
+     * colour token. This is what status indicators subscribe to.
+     */
+    getRobotStatusChanges(projectId, callsign, opts) {
+        const reported$ = this.getReportedStatusChanges(projectId, callsign).pipe(
+        // Seed so the combined stream emits (e.g. gray) before the first heartbeat arrives.
+        startWith({ health: RobotHealth.UNKNOWN, readiness: RobotReadiness.UNKNOWN }));
+        const connectivity$ = this.getConnectivityChanges(projectId, callsign, opts);
+        return combineLatest([reported$, connectivity$]).pipe(map(([reported, connectivity]) => ({
+            health: reported.health,
+            readiness: reported.readiness,
+            connectivity,
+            colour: getRobotStatusColour({ health: reported.health, readiness: reported.readiness, connectivity }),
+        })), distinctUntilChanged(robotStatusEquals));
+    }
+    getError(e) {
+        return new RocosError(e, errorCodes.ROBOT_STATUS_SERVICE_ERROR);
+    }
+    get telemetryService() {
+        return RocosStore.getSDKInstance(this.config).getTelemetryService();
+    }
+    connectivityDeps(projectId, callsign, opts) {
+        return {
+            httpGet: (url) => {
+                return this.callGet(url, `Failed to get connection status for ${callsign} in project ${projectId}.`);
+            },
+            baseUrl: this.config.url,
+            insecure: this.config.insecure,
+            telemetryLiveness$: getTelemetryLiveness(this.telemetryService, projectId, callsign, opts?.heartbeatTimeoutMs),
+        };
+    }
+}

package/esm/services/index.d.ts

@@ -17,6 +17,7 @@ export * from './ProfileService';
 export * from './ProjectService';
 export * from './RTPWebRTCService';
 export * from './RobotService';
+export * from './RobotStatusService';
 export * from './ScheduleService';
 export * from './SearchService';
 export * from './SpotProvisioningService';

package/esm/services/index.js

@@ -17,6 +17,7 @@ export * from './ProfileService';
 export * from './ProjectService';
 export * from './RTPWebRTCService';
 export * from './RobotService';
+export * from './RobotStatusService';
 export * from './ScheduleService';
 export * from './SearchService';
 export * from './SpotProvisioningService';