@dronedeploy/rocos-js-sdk 4.4.5 → 4.4.7

package/cjs/api/StreamRegister.js

@@ -82,13 +82,13 @@ class StreamRegister {
             return;
         // Wait for init to settle before tearing down, so init can never open resources on an already
         // stopped stream. A re-acquire in the meantime revives the entry and cancels the teardown.
-        void entry.ready
-            .catch(() => undefined)
-            .then(() => {
+        const evictIfUnheld = () => {
             if (this.entries.get(identifier) === entry && entry.refCount <= 0) {
                 this.evict(identifier, entry.stream);
             }
-        })
+        };
+        void entry.ready
+            .then(() => evictIfUnheld(), () => evictIfUnheld())
             .catch((e) => this.logger.error(`Failed to evict stream. identifier: ${identifier}`, e));
     }
     evict(identifier, stream) {

package/cjs/api/streams/caller/CallerStreamAbstract.js

@@ -29,7 +29,8 @@ class CallerStreamAbstract {
         this.token = token;
     }
     stopStream() {
-        // do nothing for now
+        this.statusStream$.next(models_1.SubscriberStatusEnum.STOPPED);
+        this.statusStream$.complete();
     }
     invokeRequest(params) {
         this.logger.info('invokeRequest', params);

package/cjs/api/streams/command/CommandStreamAbstract.js

@@ -31,7 +31,8 @@ class CommandStreamAbstract {
         this.token = token;
     }
     stopStream() {
-        // do nothing for now
+        this.statusStream$.next(models_1.SubscriberStatusEnum.STOPPED);
+        this.statusStream$.complete();
     }
     invokeRequest(params) {
         if (params.timeoutMs === undefined || params.timeoutMs === null) {

package/cjs/api/streams/control/ControlStreamAbstract.js

@@ -28,7 +28,8 @@ class ControlStreamAbstract {
         this.token = token;
     }
     stopStream() {
-        // do nothing for now
+        this.statusStream$.next(models_1.SubscriberStatusEnum.STOPPED);
+        this.statusStream$.complete();
     }
     takeActionWithAck(action, params, ackTimeoutInSeconds = 15) {
         return new rxjs_1.Observable((emitter) => {

package/cjs/api/streams/fileAccessor/FileAccessorStreamAbstract.js

@@ -27,7 +27,8 @@ class FileAccessorStreamAbstract {
         this.token = token;
     }
     stopStream() {
-        // do nothing for now
+        this.statusStream$.next(models_1.SubscriberStatusEnum.STOPPED);
+        this.statusStream$.complete();
     }
     async serverReqOp(params) {
         return this.serverReqOpInternal(params);

package/cjs/api/streams/search/SearchStreamAbstract.js

@@ -28,7 +28,8 @@ class SearchStreamAbstract {
         this.token = token;
     }
     stopStream() {
-        // do nothing for now
+        this.statusStream$.next(models_1.SubscriberStatusEnum.STOPPED);
+        this.statusStream$.complete();
     }
     searchStream(params) {
         const request = this.convertToQueryMessage(params.query);

package/cjs/api/streams/telemetry/TelemetryStream.js

@@ -24,6 +24,7 @@ class TelemetryStream extends TelemetryStreamAbstract_1.TelemetryStreamAbstract
         this.client = new teletubby_pb_client_1.TelemetryGatewayClient(transport);
     }
     stopInternal() {
+        this.subscriberId = undefined;
         if (this.abortController) {
             this.logger.info('Starting stop stream process');
             this.abortController.abort();

package/cjs/api/streams/telemetry/TelemetryStreamAbstract.js

@@ -13,6 +13,33 @@ const arrayRemove_1 = require("../../../helpers/arrayRemove");
 const arrayUnique_1 = require("../../../helpers/arrayUnique");
 const operators_1 = require("rxjs/operators");
 const getSubscriptionsDifference_1 = require("../../../helpers/getSubscriptionsDifference");
+const telemetryActionQueueStates = new WeakMap();
+const resolveTelemetryActions = (actions) => {
+    actions.forEach((action) => action.resolve());
+};
+const resolveUnsentTelemetryActions = (queueState) => {
+    resolveTelemetryActions(queueState.pendingActions.splice(0));
+};
+const takeNextTelemetryBatch = (queueState) => {
+    const firstAction = queueState.pendingActions.shift();
+    if (!firstAction)
+        return [];
+    const activeBatch = [firstAction];
+    if (firstAction.callsignsLookup.isQuery() || firstAction.terminate)
+        return activeBatch;
+    while (queueState.pendingActions.length > 0) {
+        const [nextAction] = queueState.pendingActions;
+        if (nextAction.callsignsLookup.isQuery() ||
+            nextAction.terminate ||
+            nextAction.actionType !== firstAction.actionType ||
+            nextAction.subscriberId !== firstAction.subscriberId ||
+            nextAction.registration !== firstAction.registration) {
+            break;
+        }
+        activeBatch.push(queueState.pendingActions.shift());
+    }
+    return activeBatch;
+};
 class TelemetryStreamAbstract {
     constructor(config) {
         this.telemetryActionQueue = Promise.resolve();
@@ -38,6 +65,14 @@ class TelemetryStreamAbstract {
         this.messageStream$ = new rxjs_1.Subject();
         this.statusStream$ = new rxjs_1.BehaviorSubject(models_1.SubscriberStatusEnum.STOPPED);
         this.heartbeat = new StreamHeartbeat_1.StreamHeartbeat(this.identifier);
+        telemetryActionQueueStates.set(this, {
+            pendingActions: [],
+            activeBatch: [],
+            registration: 0,
+            drainScheduled: false,
+            requestInFlight: false,
+            stopped: false,
+        });
         RocosStore_1.RocosStore.getChangeSubject()
             .pipe((0, operators_1.filter)((message) => {
             return message.type === 'token' && message.url === this.url;
@@ -55,6 +90,12 @@ class TelemetryStreamAbstract {
         this.registerReceiver();
     }
     stopStream() {
+        const queueState = telemetryActionQueueStates.get(this);
+        if (queueState) {
+            queueState.stopped = true;
+            resolveUnsentTelemetryActions(queueState);
+        }
+        this.subscriberId = undefined;
         this.heartbeat?.stop();
         this.stopInternal();
         if (this.messagesTimer) {
@@ -62,6 +103,10 @@ class TelemetryStreamAbstract {
         }
         this.subscriberStatus = models_1.SubscriberStatusEnum.STOPPED;
         this.statusStream$.next(this.subscriberStatus);
+        // The stream is being torn down (the registry only stops a stream when it is evicted), so
+        // complete the status stream: this releases every service-level forwarder subscribed to it
+        // rather than leaving them attached to a dead instance.
+        this.statusStream$.complete();
     }
     addSubscription(params) {
         this.logger.info('Adding subscriptions from stream', params.uniqueId);
@@ -83,7 +128,9 @@ class TelemetryStreamAbstract {
                 const toAdd = (0, arrayRemove_1.arrayRemove)(this.sources, sourcesBefore);
                 if (toAdd.length) {
                     this.logger.debug('New query subscriptions added, we need to refresh sources', { toAdd });
-                    void this.enqueueTelemetryAction('subscribe', this.callsignsLookup, toAdd);
+                    void this.enqueueTelemetryAction('subscribe', this.callsignsLookup, toAdd).catch((error) => {
+                        this.logger.error(`Failed to subscribe: ${error}`);
+                    });
                 }
             }
             else {
@@ -94,7 +141,9 @@ class TelemetryStreamAbstract {
                 const { toAdd } = (0, getSubscriptionsDifference_1.getSubscriptionsDifference)(before, after);
                 if (toAdd.callsigns.length && toAdd.sources.length) {
                     this.logger.debug('New subscriptions added, we need to refresh sources', { toAdd });
-                    void this.enqueueTelemetryAction('subscribe', new models_1.CallsignsLookup(toAdd.callsigns), toAdd.sources);
+                    void this.enqueueTelemetryAction('subscribe', new models_1.CallsignsLookup(toAdd.callsigns), toAdd.sources).catch((error) => {
+                        this.logger.error(`Failed to subscribe: ${error}`);
+                    });
                 }
             }
         }
@@ -200,14 +249,22 @@ class TelemetryStreamAbstract {
             // Subscribe message
             case grpc_1.GRPC_SOURCE_SUBSCRIBED: {
                 const { subscriberId } = rocosMessage.payload;
+                const queueState = telemetryActionQueueStates.get(this);
+                if (queueState?.stopped)
+                    return;
                 if (this.subscriberId && subscriberId) {
                     this.logger.warn(`Replacing old subscriberId (${this.subscriberId}) with a new one (${subscriberId})`);
                 }
-                // Update the subscriberId
+                if (queueState) {
+                    queueState.registration++;
+                    resolveUnsentTelemetryActions(queueState);
+                }
                 this.subscriberId = subscriberId;
                 rocosMessage.subscriberId = this.subscriberId;
                 this.logger.info('onData', `subscriberId has been updated - ${subscriberId}`, { subscriberId });
-                void this.enqueueTelemetryAction('subscribe');
+                void this.enqueueTelemetryAction('subscribe').catch((error) => {
+                    this.logger.error(`Failed to subscribe: ${error}`);
+                });
                 this.heartbeat.start(() => this.sendHeartbeat(), this.sendHeartbeatTime);
                 isRobotMessage = false;
                 break;
@@ -249,21 +306,69 @@ class TelemetryStreamAbstract {
      * unsubscribe landing last strands a subscribe and nothing re-adds it.
      */
     enqueueTelemetryAction(actionType, callsignsLookup, sources, terminate) {
-        const takeAction = () => this.takeTelemetryAction(actionType, callsignsLookup, sources, terminate);
-        const run = this.telemetryActionQueue.then(takeAction);
-        // The tail only signals whose turn it is, so it must never reject, otherwise one failed op
-        // would wedge every op queued behind it. Callers still see the failure through `run`.
-        this.telemetryActionQueue = run.then(() => undefined, () => undefined);
-        return run;
+        const queueState = telemetryActionQueueStates.get(this);
+        if (!queueState || queueState.stopped)
+            return Promise.resolve();
+        const completion = new Promise((resolve, reject) => {
+            queueState.pendingActions.push({
+                actionType,
+                callsignsLookup: callsignsLookup ?? this.callsignsLookup,
+                sources: [...(sources ?? this.sources)],
+                terminate: terminate ?? false,
+                subscriberId: this.subscriberId,
+                registration: queueState.registration,
+                resolve,
+                reject,
+            });
+        });
+        const scheduleDrain = () => {
+            if (queueState.stopped ||
+                queueState.requestInFlight ||
+                queueState.drainScheduled ||
+                queueState.pendingActions.length === 0) {
+                return;
+            }
+            queueState.drainScheduled = true;
+            this.telemetryActionQueue = this.telemetryActionQueue.then(async () => {
+                queueState.drainScheduled = false;
+                if (queueState.stopped || queueState.requestInFlight)
+                    return;
+                const activeBatch = takeNextTelemetryBatch(queueState);
+                const [firstAction] = activeBatch;
+                if (!firstAction)
+                    return;
+                queueState.activeBatch = activeBatch;
+                queueState.requestInFlight = true;
+                try {
+                    await this.takeTelemetryAction(firstAction.actionType, firstAction.callsignsLookup, firstAction.sources);
+                    resolveTelemetryActions(activeBatch);
+                }
+                catch (error) {
+                    activeBatch.forEach((action) => action.reject(error));
+                }
+                finally {
+                    queueState.activeBatch = [];
+                    queueState.requestInFlight = false;
+                    scheduleDrain();
+                }
+            });
+        };
+        scheduleDrain();
+        return completion;
     }
-    async takeTelemetryAction(actionType, callsignsLookup, sources, terminate) {
+    async takeTelemetryAction(actionType, callsignsLookup, sources) {
         this.logger.debug('takeTelemetryAction', actionType);
+        const queueState = telemetryActionQueueStates.get(this);
+        const activeBatch = queueState?.activeBatch ?? [];
+        const [firstAction] = activeBatch;
         // A config fault, not a race: this stream can never address a request.
         if (!this.projectId) {
             this.logger.warn('takeTelemetryAction', actionType, `${actionType} without a projectId - dropped`);
             return Promise.resolve();
         }
-        if (!this.subscriberId) {
+        if (!firstAction?.subscriberId ||
+            firstAction.subscriberId !== this.subscriberId ||
+            firstAction.registration !== queueState?.registration) {
             // Deferred, not lost: `onData` re-asserts `this.sources` when the subscriberId arrives.
             this.logger.debug('takeTelemetryAction', actionType, `${actionType} before the receiver was registered - deferred to the post-registration re-assert`);
             return Promise.resolve();
@@ -271,20 +376,20 @@ class TelemetryStreamAbstract {
         const actionSources = sources ?? this.sources;
         const actionCallsigns = callsignsLookup ?? this.callsignsLookup;
         if (!actionCallsigns.isQuery()) {
-            // Compose the request message
             const req = teletubby_pb_1.TelemetryRequest.create({
-                subscriberId: this.subscriberId,
-                requestedActions: [
-                    {
-                        operation: actionType,
-                        callsigns: actionCallsigns.getCallsigns(),
-                        sources: actionSources,
-                    },
-                ],
+                subscriberId: firstAction.subscriberId,
+                requestedActions: activeBatch.map((action) => {
+                    const telemetryAction = teletubby_pb_1.TelemetryAction.create({
+                        operation: action.actionType,
+                        callsigns: action.callsignsLookup.getCallsigns(),
+                        sources: action.sources,
+                    });
+                    if (action.actionType === 'unsubscribe' && action.terminate) {
+                        this.addTerminateToAction(telemetryAction);
+                    }
+                    return telemetryAction;
+                }),
             });
-            if (actionType === 'unsubscribe' && terminate) {
-                this.addTerminateToAction(req.requestedActions[0]);
-            }
             this.logger.debug('takeTelemetryAction', actionType, 'client.requestTelemetry', this.subscriberId);
             // Send the message to back-end.
             return this.requestTelemetry(req);
@@ -309,7 +414,7 @@ class TelemetryStreamAbstract {
             });
             // Compose the request message
             const req = teletubby_pb_1.TelemetryQueryRequest.create({
-                subscriberId: this.subscriberId,
+                subscriberId: firstAction.subscriberId,
                 sources: actionSources,
                 operation: actionType,
                 callsignQuery: {

package/cjs/api/streams/telemetry/TelemetryStreamConnect.js

@@ -40,6 +40,7 @@ class TelemetryStreamConnect extends TelemetryStreamAbstract_1.TelemetryStreamAb
         this.client = (0, connect_1.createClient)(teletubby_pb_1.TelemetryGateway, transport);
     }
     stopInternal() {
+        this.subscriberId = undefined;
         if (this.abortController) {
             this.logger.info('Starting stop stream process');
             this.abortController.abort();

package/cjs/api/streams/telemetry/TelemetryStreamNode.js

@@ -48,6 +48,7 @@ class TelemetryStreamNode extends TelemetryStreamAbstract_1.TelemetryStreamAbstr
         this.credentials = config.insecure ? grpc.credentials.createInsecure() : grpc.credentials.createSsl();
     }
     stopInternal() {
+        this.subscriberId = undefined;
         try {
             this.logger.info('Starting stop stream process');
             this.logger.info('Stopping stream');

package/cjs/api/streams/webRTCSignalling/WebRTCSignallingStreamAbstract.js

@@ -28,7 +28,8 @@ class WebRTCSignallingStreamAbstract {
         this.token = token;
     }
     stopStream() {
-        // do nothing for now
+        this.statusStream$.next(models_1.SubscriberStatusEnum.STOPPED);
+        this.statusStream$.complete();
     }
     /**
      * Connect operator

package/cjs/models/maps/Map.d.ts

@@ -8,6 +8,6 @@ export interface Map {
     deployedCount: number;
     isUploading: boolean;
     isInCloud: boolean;
-    hash: string;
+    hash?: string;
     lastModifiedTimestamp: number;
 }

package/cjs/models/robot-status/RobotStatus.d.ts

@@ -41,3 +41,26 @@ export interface RobotStatus {
     connectivity: RobotConnectivityStatus;
     colour: RobotStatusColour;
 }
+/**
+ * One contributor to a reported-status axis, from the agent's
+ * `robot/status/contributors` topic. `status` is the contributor's own verdict
+ * for that axis — the integer wire value mapped onto the enum.
+ */
+export interface RobotStatusContributor<TStatus = RobotHealth | RobotReadiness> {
+    /** Identifier of the contributor, e.g. `battery`. */
+    id: string;
+    /** The agent component that raised it, e.g. `dji`. */
+    component: string;
+    /** Human-readable explanation, e.g. `battery below 20%`; empty when none was given. */
+    reason: string;
+    /** The contributor's verdict for its axis. */
+    status: TStatus;
+}
+/**
+ * The per-contributor breakdown behind a robot's reported health and readiness,
+ * from the agent's `robot/status/contributors` topic.
+ */
+export interface RobotStatusContributors {
+    health: RobotStatusContributor<RobotHealth>[];
+    readiness: RobotStatusContributor<RobotReadiness>[];
+}

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

@@ -30,13 +30,22 @@ export declare enum RobotReadiness {
     BUSY = "busy"
 }
 /**
- * Whether the robot is connected to a single cloud service, as reported by that
- * service's `connections` endpoint (or, for `telemetry-liveness`, derived from
- * heartbeat freshness).
+ * Whether the robot is connected to a single cloud service — reported by that
+ * service's `connections` endpoint, derived from heartbeat freshness (for
+ * `telemetry-liveness`), or supplied by a caller-injected signal
+ * (`RobotStatusOptions.extraServices`), the only source that can report {@link FAILED}.
  */
 export declare enum ServiceConnection {
     CONNECTED = "connected",
     DISCONNECTED = "disconnected",
+    /**
+     * The service reports an explicit fault — a stronger signal than {@link DISCONNECTED} (which just
+     * means "not connected", as expected of a robot that is simply off). A failed virtual-robot
+     * deployment is the motivating case. Any `FAILED` service forces the aggregate to
+     * {@link RobotConnectivity.DEGRADED}, so a fault raises attention even when nothing else is
+     * connected — see `aggregateConnectivity`.
+     */
+    FAILED = "failed",
     /** The service's connectivity has not yet been determined (e.g. not polled). */
     UNKNOWN = "unknown"
 }
@@ -45,10 +54,13 @@ export declare enum ServiceConnection {
  * expected services.
  */
 export declare enum RobotConnectivity {
-    /** At least one expected service is connected and none is disconnected. */
+    /** At least one expected service is connected and none is disconnected or failed. */
     ONLINE = "online",
-    /** Some, but not all, expected services report connected. */
+    /**
+     * Any service reports a fault ({@link ServiceConnection.FAILED}), or a genuine mix — some
+     * connected, some disconnected. A `FAILED` service forces this even when nothing is connected.
+     */
     DEGRADED = "degraded",
-    /** No expected service reports connected. */
+    /** Nothing connected, and nothing failed. */
     OFFLINE = "offline"
 }

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

@@ -35,14 +35,23 @@ var RobotReadiness;
     RobotReadiness["BUSY"] = "busy";
 })(RobotReadiness || (exports.RobotReadiness = RobotReadiness = {}));
 /**
- * Whether the robot is connected to a single cloud service, as reported by that
- * service's `connections` endpoint (or, for `telemetry-liveness`, derived from
- * heartbeat freshness).
+ * Whether the robot is connected to a single cloud service — reported by that
+ * service's `connections` endpoint, derived from heartbeat freshness (for
+ * `telemetry-liveness`), or supplied by a caller-injected signal
+ * (`RobotStatusOptions.extraServices`), the only source that can report {@link FAILED}.
  */
 var ServiceConnection;
 (function (ServiceConnection) {
     ServiceConnection["CONNECTED"] = "connected";
     ServiceConnection["DISCONNECTED"] = "disconnected";
+    /**
+     * The service reports an explicit fault — a stronger signal than {@link DISCONNECTED} (which just
+     * means "not connected", as expected of a robot that is simply off). A failed virtual-robot
+     * deployment is the motivating case. Any `FAILED` service forces the aggregate to
+     * {@link RobotConnectivity.DEGRADED}, so a fault raises attention even when nothing else is
+     * connected — see `aggregateConnectivity`.
+     */
+    ServiceConnection["FAILED"] = "failed";
     /** The service's connectivity has not yet been determined (e.g. not polled). */
     ServiceConnection["UNKNOWN"] = "unknown";
 })(ServiceConnection || (exports.ServiceConnection = ServiceConnection = {}));
@@ -52,10 +61,13 @@ var ServiceConnection;
  */
 var RobotConnectivity;
 (function (RobotConnectivity) {
-    /** At least one expected service is connected and none is disconnected. */
+    /** At least one expected service is connected and none is disconnected or failed. */
     RobotConnectivity["ONLINE"] = "online";
-    /** Some, but not all, expected services report connected. */
+    /**
+     * Any service reports a fault ({@link ServiceConnection.FAILED}), or a genuine mix — some
+     * connected, some disconnected. A `FAILED` service forces this even when nothing is connected.
+     */
     RobotConnectivity["DEGRADED"] = "degraded";
-    /** No expected service reports connected. */
+    /** Nothing connected, and nothing failed. */
     RobotConnectivity["OFFLINE"] = "offline";
 })(RobotConnectivity || (exports.RobotConnectivity = RobotConnectivity = {}));

package/cjs/services/RobotStatusService.d.ts

@@ -1,4 +1,4 @@
-import { IBaseService, IRocosSDKConfig, RobotConnectivityStatus, RobotStatus, RocosError } from '../models';
+import { IBaseService, IRocosSDKConfig, RobotConnectivityStatus, RobotStatus, RobotStatusContributors, RocosError, ServiceConnection } from '../models';
 import { Observable } from 'rxjs';
 import { ReportedRobotStatus } from './robot-status/reportedStatus';
 import { BaseServiceAbstract } from './BaseServiceAbstract';
@@ -10,6 +10,23 @@ export interface RobotStatusOptions {
     heartbeatTimeoutMs?: number;
     /** How often the connections endpoints are polled (ms, floored internally). */
     connectivityPollMs?: number;
+    /**
+     * Extra per-robot connectivity signals, keyed by service id, folded into
+     * {@link RobotConnectivityStatus.services} and the aggregate on equal footing with the built-in
+     * services. Lets a caller inject a signal the SDK can't derive itself (e.g. virtual-robot
+     * deployment status); emit {@link ServiceConnection.FAILED} to surface a fault as `DEGRADED`.
+     *
+     * A key that collides with a built-in service id (`telemetry-liveness`, `robot-configs`,
+     * `robot-services`) is ignored in favour of the built-in.
+     *
+     * An error from an injected observable is contained as {@link ServiceConnection.UNKNOWN} so it
+     * can't tear down the overall status stream — but it is *terminal* for that signal: unlike the
+     * built-in HTTP poller (which recovers on its next tick), the errored observable is not
+     * resubscribed, so the service stays `UNKNOWN` for the life of the stream (and `getConnectivity`
+     * then waits out its timeout). To report a recoverable fault, emit `FAILED` / `UNKNOWN` as a
+     * value rather than letting the observable error.
+     */
+    extraServices?: Record<string, Observable<ServiceConnection>>;
 }
 /**
  * The single source of truth for a robot's status. It composes the reported
@@ -22,6 +39,8 @@ export declare class RobotStatusService extends BaseServiceAbstract implements I
     getStatus(): boolean;
     /** Health + readiness as reported by the robot (new topic, legacy heartbeat fallback). */
     getReportedStatusChanges(projectId: string, callsign: string): Observable<ReportedRobotStatus>;
+    /** Per-contributor breakdown behind the reported health and readiness, with the reason for each. */
+    getStatusContributorsChanges(projectId: string, callsign: string): Observable<RobotStatusContributors>;
     /** 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. */

package/cjs/services/RobotStatusService.js

@@ -42,6 +42,10 @@ class RobotStatusService extends BaseServiceAbstract_1.BaseServiceAbstract {
     getReportedStatusChanges(projectId, callsign) {
         return (0, reportedStatus_1.getReportedStatusChanges)(this.telemetryService, projectId, callsign);
     }
+    /** Per-contributor breakdown behind the reported health and readiness, with the reason for each. */
+    getStatusContributorsChanges(projectId, callsign) {
+        return (0, reportedStatus_1.getStatusContributorsChanges)(this.telemetryService, projectId, callsign);
+    }
     /** Per-service connectivity plus the aggregate verdict, polled. */
     getConnectivityChanges(projectId, callsign, opts) {
         return (0, connectivity_1.getConnectivityChanges)(this.connectivityDeps(projectId, callsign, opts), projectId, callsign, opts?.expectedServices, opts?.connectivityPollMs);
@@ -88,6 +92,7 @@ class RobotStatusService extends BaseServiceAbstract_1.BaseServiceAbstract {
             baseUrl: this.config.url,
             insecure: this.config.insecure,
             telemetryLiveness$: (0, reportedStatus_1.getTelemetryLiveness)(this.telemetryService, projectId, callsign, opts?.heartbeatTimeoutMs),
+            extraServices: opts?.extraServices,
         };
     }
 }

package/cjs/services/SearchService.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SearchService = void 0;
-const models_1 = require("../models");
 const rxjs_1 = require("rxjs");
 const BaseStreamService_1 = require("./BaseStreamService");
 const identifier_1 = require("../constants/identifier");
@@ -47,12 +46,8 @@ class SearchService extends BaseStreamService_1.BaseStreamService {
             port: this.config.port,
             insecure: this.config.insecure,
         });
-        if (newStream.isNew) {
-            newStream.stream.statusStream$.subscribe((msg) => {
-                this.status = msg === models_1.SubscriberStatusEnum.STOPPED || msg === models_1.SubscriberStatusEnum.ALIVE;
-                this.status$.next(msg);
-            });
-        }
+        // The status forwarder is wired once per stream by BaseStreamService.acquireStream's factory
+        // (and released now that the stream completes statusStream$ on stop), so no per-service one here.
         return newStream.stream;
     }
     getStream(config) {

package/cjs/services/TelemetryService.d.ts

@@ -3,7 +3,6 @@ import { CallsignStatus, IRocosSDKConfig, IRocosTelemetryMessage, IStreamStatusM
 import { BaseStreamService } from './BaseStreamService';
 export declare class TelemetryService extends BaseStreamService<ITelemetryStream, ITelemetryStreamConfig> {
     private static grpcWebDeprecationWarned;
-    private statusSubscription;
     private changeStream$;
     private streamStatusSubject$;
     constructor(config: IRocosSDKConfig);
@@ -29,6 +28,10 @@ export declare class TelemetryService extends BaseStreamService<ITelemetryStream
     getStatusChanges(): Observable<IStreamStatusMessage>;
     /**
      * Subscribes to the heartbeat telemetry and checks we receive one at least every 5s
+     *
+     * @deprecated Superseded by {@link RobotStatusService.getRobotStatusChanges}, which reports the
+     * normalised robot status (reported health/readiness plus platform connectivity) rather than only
+     * heartbeat-derived online/offline liveness.
      * @param projectId
      * @param callsign
      * @param heartbeatTimeoutMs optionally override the deadline for heartbeats (in ms). Default 5000ms

package/cjs/services/TelemetryService.js

@@ -67,7 +67,9 @@ class TelemetryService extends BaseStreamService_1.BaseStreamService {
             const { stream, isNew, ready, release } = this.acquireStream(identifier_1.IDENTIFIER_NAME_TELEMETRY, this.buildStreamConfig(params.projectId, callsignsLookup, sources, scope));
             try {
                 stream.addSubscription(subscriptionParams);
-                if (!isNew) {
+                // Forward the stream's status onto the per-scope subject once, at creation; it ends when the
+                // stream stops (statusStream$ completes), so it is not re-created or leaked across subscribers.
+                if (isNew) {
                     stream.statusStream$.subscribe((msg) => {
                         this.streamStatusSubject$.next({
                             scope,
@@ -81,20 +83,19 @@ class TelemetryService extends BaseStreamService_1.BaseStreamService {
                 release();
                 throw e;
             }
-            const messages$ = ready.then(() => {
-                if (!this.statusSubscription) {
-                    this.statusSubscription = stream.statusStream$.subscribe((msg) => {
-                        this.status = msg === models_1.SubscriberStatusEnum.STOPPED || msg === models_1.SubscriberStatusEnum.ALIVE;
-                        this.status$.next(msg);
-                    });
-                }
-                return (0, rxjs_1.from)(stream.messageStream$);
-            });
+            // status$ / getStatus() are driven by the acquireStream factory (BaseStreamService), not here.
+            const messages$ = ready.then(() => (0, rxjs_1.from)(stream.messageStream$));
             return (0, rxjs_1.from)(messages$).pipe((0, rxjs_1.mergeAll)(), (0, operators_1.filter)((message) => {
                 return callsignsLookup.includesCallsign(message.callsign) && sources.includes(message.source);
             }), (0, operators_1.finalize)(() => {
-                void stream.removeSubscription(subscriptionParams, params.terminateReceiverGroupOnUnsubscribe);
-                release();
+                if (params.terminateReceiverGroupOnUnsubscribe) {
+                    const removal = stream.removeSubscription(subscriptionParams, true);
+                    void Promise.resolve(removal).finally(release);
+                }
+                else {
+                    release();
+                    void stream.removeSubscription(subscriptionParams);
+                }
             }));
         });
     }
@@ -116,6 +117,10 @@ class TelemetryService extends BaseStreamService_1.BaseStreamService {
     }
     /**
      * Subscribes to the heartbeat telemetry and checks we receive one at least every 5s
+     *
+     * @deprecated Superseded by {@link RobotStatusService.getRobotStatusChanges}, which reports the
+     * normalised robot status (reported health/readiness plus platform connectivity) rather than only
+     * heartbeat-derived online/offline liveness.
      * @param projectId
      * @param callsign
      * @param heartbeatTimeoutMs optionally override the deadline for heartbeats (in ms). Default 5000ms