@dronedeploy/rocos-js-sdk 4.4.6 → 4.4.8

package/cjs/api/StreamRegister.d.ts

@@ -10,8 +10,12 @@ export interface IAcquiredStream<T extends IBaseStream> {
 /**
  * Sole owner of stream lifecycle. Streams are shared per identifier and refcounted: acquireStream
  * gets-or-creates and increments in one synchronous step, and the returned handle's release()
- * tears the stream down when the last holder leaves. Teardown never happens outside
- * release/removeAllStreams, so a held stream can not be stopped or replaced underneath its holders.
+ * tears the stream down when the last holder leaves.
+ *
+ * A held stream can also be stopped and replaced underneath its holders, by reportStreamDead, when
+ * the stream can no longer carry anything. Holders keep the instance they were handed; their
+ * release() finds the entry gone and does nothing, so a replacement never inherits a departing
+ * holder's refcount and a refcount can not go negative.
  */
 export declare class StreamRegister {
     private entries;
@@ -22,6 +26,7 @@ export declare class StreamRegister {
     static getIdentifier($identifier: string, scope?: string): string;
     acquireStream<T extends IBaseStream>(identifier: string, create: () => T, init: (stream: T) => Promise<void>): IAcquiredStream<T>;
     getStream(identifier: string): IBaseStream | undefined;
+    reportStreamDead(identifier: string, stream: IBaseStream): void;
     removeAllStreams(): boolean;
     private release;
     private evict;

package/cjs/api/StreamRegister.js

@@ -6,8 +6,12 @@ const RocosLogger_1 = require("../logger/RocosLogger");
 /**
  * Sole owner of stream lifecycle. Streams are shared per identifier and refcounted: acquireStream
  * gets-or-creates and increments in one synchronous step, and the returned handle's release()
- * tears the stream down when the last holder leaves. Teardown never happens outside
- * release/removeAllStreams, so a held stream can not be stopped or replaced underneath its holders.
+ * tears the stream down when the last holder leaves.
+ *
+ * A held stream can also be stopped and replaced underneath its holders, by reportStreamDead, when
+ * the stream can no longer carry anything. Holders keep the instance they were handed; their
+ * release() finds the entry gone and does nothing, so a replacement never inherits a departing
+ * holder's refcount and a refcount can not go negative.
  */
 class StreamRegister {
     constructor() {
@@ -62,6 +66,17 @@ class StreamRegister {
     getStream(identifier) {
         return this.entries.get(identifier)?.stream;
     }
+    reportStreamDead(identifier, stream) {
+        if (this.entries.get(identifier)?.stream !== stream)
+            return; // already evicted, or already replaced
+        this.logger.warn(`Stream reported dead, evicting so the next acquirer builds a new one. identifier: ${identifier}`);
+        try {
+            this.evict(identifier, stream);
+        }
+        catch (e) {
+            this.logger.error(`Failed to evict dead stream. identifier: ${identifier}`, e);
+        }
+    }
     removeAllStreams() {
         for (const [, entry] of this.entries.entries()) {
             try {
@@ -82,13 +97,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.d.ts

@@ -29,6 +29,7 @@ export declare abstract class TelemetryStreamAbstract implements ITelemetryStrea
     private sendHeartbeatTime;
     private receivedDataStats;
     private subscriptions;
+    private receiverDead;
     constructor(config: ITelemetryStreamConfig);
     protected abstract stopInternal(): void;
     protected abstract registerReceiver(): () => void;
@@ -41,6 +42,8 @@ export declare abstract class TelemetryStreamAbstract implements ITelemetryStrea
     stopStream(): void;
     addSubscription(params: ITelemetryParams): void;
     removeSubscription(params: ITelemetryParams, terminateReceiverGroup?: boolean): Promise<void>;
+    private onBackgroundActionFailure;
+    private markReceiverDead;
     private isQueryLookup;
     private getSubscribedSources;
     sendAcknowledgment(uid: string, status: TelemetryAckStatus, noRetry: boolean): boolean;
@@ -55,6 +58,7 @@ export declare abstract class TelemetryStreamAbstract implements ITelemetryStrea
     private takeTelemetryAction;
     protected listenMessagesAndRenew(): void;
     private addTerminateToAction;
+    private renewReceiver;
     private messageTimeoutTryAgain;
     /**
      * Auto resubscribe to reduce CPU usage.

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

@@ -13,6 +13,41 @@ 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 isReceiverGoneError = (error) => {
+    const code = error?.code;
+    if (typeof code === 'number')
+        return code === 9; // gRPC FAILED_PRECONDITION
+    if (typeof code === 'string')
+        return code.toLowerCase() === 'failed_precondition';
+    return false;
+};
+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();
@@ -26,6 +61,7 @@ class TelemetryStreamAbstract {
         this.sendHeartbeatTime = 5000;
         this.receivedDataStats = {};
         this.subscriptions = new Map();
+        this.receiverDead = false;
         this.identifier = StreamRegister_1.StreamRegister.getIdentifier(identifier_1.IDENTIFIER_NAME_TELEMETRY, config.scope);
         this.projectId = config.projectId;
         this.callsignsLookup = config.callsignsLookup;
@@ -38,6 +74,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 +99,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) {
@@ -87,7 +137,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.onBackgroundActionFailure('subscribe', error);
+                    });
                 }
             }
             else {
@@ -98,7 +150,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.onBackgroundActionFailure('subscribe', error);
+                    });
                 }
             }
         }
@@ -133,7 +187,7 @@ class TelemetryStreamAbstract {
                     await this.enqueueTelemetryAction('unsubscribe', this.callsignsLookup, toRemove, terminateReceiverGroup);
                 }
                 catch (err) {
-                    this.logger.error(`Failed to unsubscribe: ${err}`);
+                    this.onBackgroundActionFailure('unsubscribe', err);
                 }
             }
             return;
@@ -148,10 +202,24 @@ class TelemetryStreamAbstract {
                 await this.enqueueTelemetryAction('unsubscribe', new models_1.CallsignsLookup(toRemove.callsigns), toRemove.sources, terminateReceiverGroup);
             }
             catch (err) {
-                this.logger.error(`Failed to unsubscribe: ${err}`);
+                this.onBackgroundActionFailure('unsubscribe', err);
             }
         }
     }
+    onBackgroundActionFailure(actionType, error) {
+        this.logger.error(`Failed to ${actionType}: ${error}`);
+        if (isReceiverGoneError(error)) {
+            this.markReceiverDead(error);
+        }
+    }
+    markReceiverDead(error) {
+        if (this.receiverDead)
+            return;
+        this.receiverDead = true;
+        this.logger.error('Receiver is no longer registered with the gateway, retiring the stream', error);
+        StreamRegister_1.StreamRegister.getInstance().reportStreamDead(this.identifier, this);
+        this.messageStream$.error(error);
+    }
     isQueryLookup() {
         return this.callsignsLookup?.isQuery() ?? false;
     }
@@ -204,14 +272,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.onBackgroundActionFailure('subscribe', error);
+                });
                 this.heartbeat.start(() => this.sendHeartbeat(), this.sendHeartbeatTime);
                 isRobotMessage = false;
                 break;
@@ -253,21 +329,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();
@@ -275,20 +399,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);
@@ -313,7 +437,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: {
@@ -413,14 +537,22 @@ class TelemetryStreamAbstract {
             unsubscribeOperation,
         };
     }
+    renewReceiver() {
+        try {
+            // Remove the received call anyway.
+            this.stopInternal();
+            this.lastMessageReceived = undefined;
+            this.lastRobotMessageReceived = undefined;
+            this.registerReceiver();
+        }
+        catch (e) {
+            this.logger.error('Failed to renew the receiver, retrying on the next check', e);
+        }
+    }
     messageTimeoutTryAgain() {
         // Increase retry times.
         this.retryTimes++;
-        // Remove the received call anyway.
-        this.stopInternal();
-        this.lastMessageReceived = undefined;
-        this.lastRobotMessageReceived = undefined;
-        this.registerReceiver();
+        this.renewReceiver();
     }
     /**
      * Auto resubscribe to reduce CPU usage.
@@ -428,11 +560,7 @@ class TelemetryStreamAbstract {
     autoResubscribe() {
         // Reset
         this.retryTimes = 0;
-        // Remove the received call anyway.
-        this.stopInternal();
-        this.lastMessageReceived = undefined;
-        this.lastRobotMessageReceived = undefined;
-        this.registerReceiver();
+        this.renewReceiver();
     }
     isFoundSource(source) {
         return this.sources.indexOf(source) !== -1;

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/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

@@ -28,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

@@ -88,8 +88,16 @@ class TelemetryService extends BaseStreamService_1.BaseStreamService {
             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)
+                        .catch(() => undefined);
+                }
+                else {
+                    release();
+                    void Promise.resolve(stream.removeSubscription(subscriptionParams)).catch(() => undefined);
+                }
             }));
         });
     }
@@ -111,6 +119,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

package/esm/api/StreamRegister.d.ts

@@ -10,8 +10,12 @@ export interface IAcquiredStream<T extends IBaseStream> {
 /**
  * Sole owner of stream lifecycle. Streams are shared per identifier and refcounted: acquireStream
  * gets-or-creates and increments in one synchronous step, and the returned handle's release()
- * tears the stream down when the last holder leaves. Teardown never happens outside
- * release/removeAllStreams, so a held stream can not be stopped or replaced underneath its holders.
+ * tears the stream down when the last holder leaves.
+ *
+ * A held stream can also be stopped and replaced underneath its holders, by reportStreamDead, when
+ * the stream can no longer carry anything. Holders keep the instance they were handed; their
+ * release() finds the entry gone and does nothing, so a replacement never inherits a departing
+ * holder's refcount and a refcount can not go negative.
  */
 export declare class StreamRegister {
     private entries;
@@ -22,6 +26,7 @@ export declare class StreamRegister {
     static getIdentifier($identifier: string, scope?: string): string;
     acquireStream<T extends IBaseStream>(identifier: string, create: () => T, init: (stream: T) => Promise<void>): IAcquiredStream<T>;
     getStream(identifier: string): IBaseStream | undefined;
+    reportStreamDead(identifier: string, stream: IBaseStream): void;
     removeAllStreams(): boolean;
     private release;
     private evict;

package/esm/api/StreamRegister.js

@@ -3,8 +3,12 @@ import { RocosLogger } from '../logger/RocosLogger';
 /**
  * Sole owner of stream lifecycle. Streams are shared per identifier and refcounted: acquireStream
  * gets-or-creates and increments in one synchronous step, and the returned handle's release()
- * tears the stream down when the last holder leaves. Teardown never happens outside
- * release/removeAllStreams, so a held stream can not be stopped or replaced underneath its holders.
+ * tears the stream down when the last holder leaves.
+ *
+ * A held stream can also be stopped and replaced underneath its holders, by reportStreamDead, when
+ * the stream can no longer carry anything. Holders keep the instance they were handed; their
+ * release() finds the entry gone and does nothing, so a replacement never inherits a departing
+ * holder's refcount and a refcount can not go negative.
  */
 export class StreamRegister {
     constructor() {
@@ -59,6 +63,17 @@ export class StreamRegister {
     getStream(identifier) {
         return this.entries.get(identifier)?.stream;
     }
+    reportStreamDead(identifier, stream) {
+        if (this.entries.get(identifier)?.stream !== stream)
+            return; // already evicted, or already replaced
+        this.logger.warn(`Stream reported dead, evicting so the next acquirer builds a new one. identifier: ${identifier}`);
+        try {
+            this.evict(identifier, stream);
+        }
+        catch (e) {
+            this.logger.error(`Failed to evict dead stream. identifier: ${identifier}`, e);
+        }
+    }
     removeAllStreams() {
         for (const [, entry] of this.entries.entries()) {
             try {
@@ -79,13 +94,13 @@ export 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/esm/api/streams/caller/CallerStreamAbstract.js

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

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

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

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

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

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

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

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

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

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

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

package/esm/api/streams/telemetry/TelemetryStreamAbstract.d.ts

@@ -29,6 +29,7 @@ export declare abstract class TelemetryStreamAbstract implements ITelemetryStrea
     private sendHeartbeatTime;
     private receivedDataStats;
     private subscriptions;
+    private receiverDead;
     constructor(config: ITelemetryStreamConfig);
     protected abstract stopInternal(): void;
     protected abstract registerReceiver(): () => void;
@@ -41,6 +42,8 @@ export declare abstract class TelemetryStreamAbstract implements ITelemetryStrea
     stopStream(): void;
     addSubscription(params: ITelemetryParams): void;
     removeSubscription(params: ITelemetryParams, terminateReceiverGroup?: boolean): Promise<void>;
+    private onBackgroundActionFailure;
+    private markReceiverDead;
     private isQueryLookup;
     private getSubscribedSources;
     sendAcknowledgment(uid: string, status: TelemetryAckStatus, noRetry: boolean): boolean;
@@ -55,6 +58,7 @@ export declare abstract class TelemetryStreamAbstract implements ITelemetryStrea
     private takeTelemetryAction;
     protected listenMessagesAndRenew(): void;
     private addTerminateToAction;
+    private renewReceiver;
     private messageTimeoutTryAgain;
     /**
      * Auto resubscribe to reduce CPU usage.

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

@@ -1,7 +1,7 @@
 import { BehaviorSubject, Subject } from 'rxjs';
 import { CallsignsLookup, RocosTelemetryMessage, StreamOptions, SubscriberStatusEnum, } from '../../../models';
 import { GRPC_SOURCE_NOOP, GRPC_SOURCE_SUBSCRIBED } from '../../../constants/grpc';
-import { QueryOrPredicate, TelemetryAckStatus, TelemetryQueryRequest, TelemetryRequest, UnsubscribeOperation, } from '../../../grpc/teletubby_pb';
+import { QueryOrPredicate, TelemetryAckStatus, TelemetryAction, TelemetryQueryRequest, TelemetryRequest, UnsubscribeOperation, } from '../../../grpc/teletubby_pb';
 import { IDENTIFIER_NAME_TELEMETRY } from '../../../constants/identifier';
 import { RocosStore } from '../../../store/RocosStore';
 import { StreamHeartbeat } from '../../atoms/StreamHeartbeat';
@@ -10,6 +10,41 @@ import { arrayRemove } from '../../../helpers/arrayRemove';
 import { arrayUnique } from '../../../helpers/arrayUnique';
 import { filter } from 'rxjs/operators';
 import { getSubscriptionsDifference } from '../../../helpers/getSubscriptionsDifference';
+const telemetryActionQueueStates = new WeakMap();
+const resolveTelemetryActions = (actions) => {
+    actions.forEach((action) => action.resolve());
+};
+const resolveUnsentTelemetryActions = (queueState) => {
+    resolveTelemetryActions(queueState.pendingActions.splice(0));
+};
+const isReceiverGoneError = (error) => {
+    const code = error?.code;
+    if (typeof code === 'number')
+        return code === 9; // gRPC FAILED_PRECONDITION
+    if (typeof code === 'string')
+        return code.toLowerCase() === 'failed_precondition';
+    return false;
+};
+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;
+};
 export class TelemetryStreamAbstract {
     constructor(config) {
         this.telemetryActionQueue = Promise.resolve();
@@ -23,6 +58,7 @@ export class TelemetryStreamAbstract {
         this.sendHeartbeatTime = 5000;
         this.receivedDataStats = {};
         this.subscriptions = new Map();
+        this.receiverDead = false;
         this.identifier = StreamRegister.getIdentifier(IDENTIFIER_NAME_TELEMETRY, config.scope);
         this.projectId = config.projectId;
         this.callsignsLookup = config.callsignsLookup;
@@ -35,6 +71,14 @@ export class TelemetryStreamAbstract {
         this.messageStream$ = new Subject();
         this.statusStream$ = new BehaviorSubject(SubscriberStatusEnum.STOPPED);
         this.heartbeat = new StreamHeartbeat(this.identifier);
+        telemetryActionQueueStates.set(this, {
+            pendingActions: [],
+            activeBatch: [],
+            registration: 0,
+            drainScheduled: false,
+            requestInFlight: false,
+            stopped: false,
+        });
         RocosStore.getChangeSubject()
             .pipe(filter((message) => {
             return message.type === 'token' && message.url === this.url;
@@ -52,6 +96,12 @@ export 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) {
@@ -84,7 +134,9 @@ export class TelemetryStreamAbstract {
                 const toAdd = 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.onBackgroundActionFailure('subscribe', error);
+                    });
                 }
             }
             else {
@@ -95,7 +147,9 @@ export class TelemetryStreamAbstract {
                 const { toAdd } = 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 CallsignsLookup(toAdd.callsigns), toAdd.sources);
+                    void this.enqueueTelemetryAction('subscribe', new CallsignsLookup(toAdd.callsigns), toAdd.sources).catch((error) => {
+                        this.onBackgroundActionFailure('subscribe', error);
+                    });
                 }
             }
         }
@@ -130,7 +184,7 @@ export class TelemetryStreamAbstract {
                     await this.enqueueTelemetryAction('unsubscribe', this.callsignsLookup, toRemove, terminateReceiverGroup);
                 }
                 catch (err) {
-                    this.logger.error(`Failed to unsubscribe: ${err}`);
+                    this.onBackgroundActionFailure('unsubscribe', err);
                 }
             }
             return;
@@ -145,10 +199,24 @@ export class TelemetryStreamAbstract {
                 await this.enqueueTelemetryAction('unsubscribe', new CallsignsLookup(toRemove.callsigns), toRemove.sources, terminateReceiverGroup);
             }
             catch (err) {
-                this.logger.error(`Failed to unsubscribe: ${err}`);
+                this.onBackgroundActionFailure('unsubscribe', err);
             }
         }
     }
+    onBackgroundActionFailure(actionType, error) {
+        this.logger.error(`Failed to ${actionType}: ${error}`);
+        if (isReceiverGoneError(error)) {
+            this.markReceiverDead(error);
+        }
+    }
+    markReceiverDead(error) {
+        if (this.receiverDead)
+            return;
+        this.receiverDead = true;
+        this.logger.error('Receiver is no longer registered with the gateway, retiring the stream', error);
+        StreamRegister.getInstance().reportStreamDead(this.identifier, this);
+        this.messageStream$.error(error);
+    }
     isQueryLookup() {
         return this.callsignsLookup?.isQuery() ?? false;
     }
@@ -201,14 +269,22 @@ export class TelemetryStreamAbstract {
             // Subscribe message
             case 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.onBackgroundActionFailure('subscribe', error);
+                });
                 this.heartbeat.start(() => this.sendHeartbeat(), this.sendHeartbeatTime);
                 isRobotMessage = false;
                 break;
@@ -250,21 +326,69 @@ export 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();
@@ -272,20 +396,20 @@ export class TelemetryStreamAbstract {
         const actionSources = sources ?? this.sources;
         const actionCallsigns = callsignsLookup ?? this.callsignsLookup;
         if (!actionCallsigns.isQuery()) {
-            // Compose the request message
             const req = TelemetryRequest.create({
-                subscriberId: this.subscriberId,
-                requestedActions: [
-                    {
-                        operation: actionType,
-                        callsigns: actionCallsigns.getCallsigns(),
-                        sources: actionSources,
-                    },
-                ],
+                subscriberId: firstAction.subscriberId,
+                requestedActions: activeBatch.map((action) => {
+                    const telemetryAction = 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);
@@ -310,7 +434,7 @@ export class TelemetryStreamAbstract {
             });
             // Compose the request message
             const req = TelemetryQueryRequest.create({
-                subscriberId: this.subscriberId,
+                subscriberId: firstAction.subscriberId,
                 sources: actionSources,
                 operation: actionType,
                 callsignQuery: {
@@ -410,14 +534,22 @@ export class TelemetryStreamAbstract {
             unsubscribeOperation,
         };
     }
+    renewReceiver() {
+        try {
+            // Remove the received call anyway.
+            this.stopInternal();
+            this.lastMessageReceived = undefined;
+            this.lastRobotMessageReceived = undefined;
+            this.registerReceiver();
+        }
+        catch (e) {
+            this.logger.error('Failed to renew the receiver, retrying on the next check', e);
+        }
+    }
     messageTimeoutTryAgain() {
         // Increase retry times.
         this.retryTimes++;
-        // Remove the received call anyway.
-        this.stopInternal();
-        this.lastMessageReceived = undefined;
-        this.lastRobotMessageReceived = undefined;
-        this.registerReceiver();
+        this.renewReceiver();
     }
     /**
      * Auto resubscribe to reduce CPU usage.
@@ -425,11 +557,7 @@ export class TelemetryStreamAbstract {
     autoResubscribe() {
         // Reset
         this.retryTimes = 0;
-        // Remove the received call anyway.
-        this.stopInternal();
-        this.lastMessageReceived = undefined;
-        this.lastRobotMessageReceived = undefined;
-        this.registerReceiver();
+        this.renewReceiver();
     }
     isFoundSource(source) {
         return this.sources.indexOf(source) !== -1;

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

@@ -37,6 +37,7 @@ export class TelemetryStreamConnect extends TelemetryStreamAbstract {
         this.client = createClient(TelemetryGateway, transport);
     }
     stopInternal() {
+        this.subscriberId = undefined;
         if (this.abortController) {
             this.logger.info('Starting stop stream process');
             this.abortController.abort();

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

@@ -12,6 +12,7 @@ export class TelemetryStreamNode extends TelemetryStreamAbstract {
         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/esm/api/streams/webRTCSignalling/WebRTCSignallingStreamAbstract.js

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

package/esm/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/esm/services/SearchService.js

@@ -1,4 +1,3 @@
-import { SubscriberStatusEnum, } from '../models';
 import { Subject } from 'rxjs';
 import { BaseStreamService } from './BaseStreamService';
 import { IDENTIFIER_NAME_SEARCH } from '../constants/identifier';
@@ -44,12 +43,8 @@ export class SearchService extends BaseStreamService {
             port: this.config.port,
             insecure: this.config.insecure,
         });
-        if (newStream.isNew) {
-            newStream.stream.statusStream$.subscribe((msg) => {
-                this.status = msg === SubscriberStatusEnum.STOPPED || msg === 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/esm/services/TelemetryService.d.ts

@@ -28,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/esm/services/TelemetryService.js

@@ -85,8 +85,16 @@ export class TelemetryService extends BaseStreamService {
             return from(messages$).pipe(mergeAll(), filter((message) => {
                 return callsignsLookup.includesCallsign(message.callsign) && sources.includes(message.source);
             }), finalize(() => {
-                void stream.removeSubscription(subscriptionParams, params.terminateReceiverGroupOnUnsubscribe);
-                release();
+                if (params.terminateReceiverGroupOnUnsubscribe) {
+                    const removal = stream.removeSubscription(subscriptionParams, true);
+                    void Promise.resolve(removal)
+                        .finally(release)
+                        .catch(() => undefined);
+                }
+                else {
+                    release();
+                    void Promise.resolve(stream.removeSubscription(subscriptionParams)).catch(() => undefined);
+                }
             }));
         });
     }
@@ -108,6 +116,10 @@ export class TelemetryService extends 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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dronedeploy/rocos-js-sdk",
-  "version": "4.4.6",
+  "version": "4.4.8",
   "description": "Javascript SDK for rocos",
   "main": "cjs/index.js",
   "module": "esm/index.js",