@dronedeploy/rocos-js-sdk 4.4.6 → 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) {
@@ -87,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 {
@@ -98,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}`);
+                    });
                 }
             }
         }
@@ -204,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;
@@ -253,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();
@@ -275,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);
@@ -313,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/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,14 @@ 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);
+                }
+                else {
+                    release();
+                    void stream.removeSubscription(subscriptionParams);
+                }
             }));
         });
     }
@@ -111,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

package/esm/api/StreamRegister.js

@@ -79,13 +79,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.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,33 @@ 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 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();
@@ -35,6 +62,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 +87,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 +125,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.logger.error(`Failed to subscribe: ${error}`);
+                    });
                 }
             }
             else {
@@ -95,7 +138,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.logger.error(`Failed to subscribe: ${error}`);
+                    });
                 }
             }
         }
@@ -201,14 +246,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.logger.error(`Failed to subscribe: ${error}`);
+                });
                 this.heartbeat.start(() => this.sendHeartbeat(), this.sendHeartbeatTime);
                 isRobotMessage = false;
                 break;
@@ -250,21 +303,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 +373,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 +411,7 @@ export class TelemetryStreamAbstract {
             });
             // Compose the request message
             const req = TelemetryQueryRequest.create({
-                subscriberId: this.subscriberId,
+                subscriberId: firstAction.subscriberId,
                 sources: actionSources,
                 operation: actionType,
                 callsignQuery: {

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,14 @@ 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);
+                }
+                else {
+                    release();
+                    void stream.removeSubscription(subscriptionParams);
+                }
             }));
         });
     }
@@ -108,6 +114,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.7",
   "description": "Javascript SDK for rocos",
   "main": "cjs/index.js",
   "module": "esm/index.js",