@dronedeploy/rocos-js-sdk 4.4.4 → 4.4.6

package/cjs/services/robot-status/connectivity.js

@@ -58,21 +58,24 @@ const mapConnectionStatus = (connection) => {
 exports.mapConnectionStatus = mapConnectionStatus;
 /**
  * Aggregates per-service connection states into an overall verdict:
- * - `ONLINE`   — at least one service connected and none disconnected.
- * - `DEGRADED` — a genuine mix: some connected, some disconnected.
+ * - `DEGRADED` — any service reports an explicit `FAILED` fault, or a genuine mix (some connected,
+ *                some disconnected).
+ * - `ONLINE`   — at least one service connected and none disconnected or failed.
  * - `OFFLINE`  — nothing connected.
  *
- * `UNKNOWN` services (e.g. not yet polled) never force `DEGRADED`, so startup
- * settles on `OFFLINE` (gray) rather than a spurious flashing-red degraded state.
+ * A `FAILED` service forces `DEGRADED` even when nothing else is connected, so a fault (e.g. a failed
+ * deployment) raises attention rather than reading as a plain, switched-off `OFFLINE`.
  *
- * Note: this optimism also means a service held `UNKNOWN` indefinitely (e.g. an
- * endpoint whose polls keep failing) does not by itself pull the aggregate below
- * `ONLINE` — a deliberate v1 tradeoff to keep transient errors from flapping the
- * indicator. Surfacing a long-lived failure distinctly (likely via health rather
- * than connectivity) is left as a future refinement.
+ * `UNKNOWN` services (e.g. not yet polled) never force `DEGRADED`, so startup settles on `OFFLINE`
+ * (gray) rather than a spurious flashing-red degraded state. This optimism also means a service held
+ * `UNKNOWN` indefinitely (e.g. an endpoint whose polls keep failing) does not by itself pull the
+ * aggregate below `ONLINE` — a deliberate tradeoff to keep transient errors from flapping the
+ * indicator; a service that wants to be surfaced reports `FAILED` explicitly.
  */
 const aggregateConnectivity = (services) => {
     const values = Object.values(services);
+    if (values.includes(models_1.ServiceConnection.FAILED))
+        return models_1.RobotConnectivity.DEGRADED;
     const hasConnected = values.includes(models_1.ServiceConnection.CONNECTED);
     const hasDisconnected = values.includes(models_1.ServiceConnection.DISCONNECTED);
     if (hasConnected && hasDisconnected)
@@ -107,24 +110,32 @@ const connectivityEquals = (a, b) => {
 };
 /**
  * Emits the robot's {@link RobotConnectivityStatus} — the per-service breakdown
- * plus the aggregate verdict — for the configured `expectedServices`. HTTP
- * services are polled; `telemetry-liveness` uses the supplied observable; any
- * unrecognised service id resolves to `UNKNOWN`.
+ * plus the aggregate verdict — for the configured `expectedServices`, plus any
+ * caller-injected `extraServices` (folded in on equal footing). HTTP services
+ * are polled; `telemetry-liveness` and injected services use their supplied
+ * observable; any unrecognised service id resolves to `UNKNOWN`.
  */
 const getConnectivityChanges = (deps, projectId, callsign, expectedServices = exports.DEFAULT_EXPECTED_SERVICES, pollMs = DEFAULT_CONNECTIVITY_POLL_MS) => {
+    const extraServices = deps.extraServices ?? {};
+    const serviceIds = [...expectedServices, ...Object.keys(extraServices).filter((id) => !expectedServices.includes(id))];
     // combineLatest([]) completes without emitting; emit an explicit empty/offline status instead.
-    if (expectedServices.length === 0) {
+    if (serviceIds.length === 0) {
         return (0, rxjs_1.of)({ overall: models_1.RobotConnectivity.OFFLINE, services: {} });
     }
-    const perService = expectedServices.map((serviceId) => {
+    const perService = serviceIds.map((serviceId) => {
         let source$;
         if (serviceId === exports.TELEMETRY_LIVENESS_SERVICE) {
             source$ = deps.telemetryLiveness$;
         }
-        else if (serviceId in exports.CONNECTION_SERVICE_PREFIXES) {
+        else if (Object.prototype.hasOwnProperty.call(exports.CONNECTION_SERVICE_PREFIXES, serviceId)) {
             const url = (0, exports.buildConnectionsUrl)(serviceId, deps.baseUrl, projectId, callsign, deps.insecure);
             source$ = (0, exports.getServiceConnectionChanges)(deps.httpGet, url, pollMs);
         }
+        else if (Object.prototype.hasOwnProperty.call(extraServices, serviceId)) {
+            // Contain an injected observable's errors as UNKNOWN, mirroring the built-in sources, so a
+            // faulty caller signal can't error out combineLatest and tear down the whole aggregate.
+            source$ = extraServices[serviceId].pipe((0, rxjs_1.catchError)(() => (0, rxjs_1.of)(models_1.ServiceConnection.UNKNOWN)));
+        }
         else {
             source$ = (0, rxjs_1.of)(models_1.ServiceConnection.UNKNOWN);
         }

package/cjs/services/robot-status/reportedStatus.d.ts

@@ -1,10 +1,12 @@
 import { Observable } from 'rxjs';
-import { RobotHealth, RobotReadiness, ServiceConnection } from '../../models';
+import { RobotHealth, RobotReadiness, RobotStatusContributors, ServiceConnection } from '../../models';
 import { TelemetryService } from '../TelemetryService';
 /** The new agent topic carrying health + readiness (replaces the heartbeat). */
 export declare const ROBOT_STATUS_SOURCE = "/diagnostics/robot/status";
 /** The legacy heartbeat topic — liveness only, no status payload. */
 export declare const LEGACY_HEARTBEAT_SOURCE = "/rocos/agent/telemetry/heartbeat";
+/** The per-contributor breakdown behind the reported status (health + readiness). */
+export declare const ROBOT_STATUS_CONTRIBUTORS_SOURCE = "/diagnostics/robot/status/contributors";
 export interface ReportedRobotStatus {
     health: RobotHealth;
     readiness: RobotReadiness;
@@ -28,6 +30,17 @@ export declare const parseRobotReadiness: (value: unknown) => RobotReadiness;
  * new topic.
  */
 export declare const getReportedStatusChanges: (telemetry: TelemetryService, projectId: string, callsign: string) => Observable<ReportedRobotStatus>;
+/**
+ * Emits the per-contributor breakdown behind the robot's reported health and
+ * readiness, from the agent's `robot/status/contributors` topic. Each
+ * contributor's integer wire value is mapped onto {@link RobotHealth} /
+ * {@link RobotReadiness}; a missing `health`/`readiness` array becomes `[]`.
+ *
+ * Starts with an empty breakdown so consumers combining this with other streams
+ * emit immediately, and — like {@link getReportedStatusChanges} — a telemetry
+ * error falls back to an empty breakdown rather than terminating the stream.
+ */
+export declare const getStatusContributorsChanges: (telemetry: TelemetryService, projectId: string, callsign: string) => Observable<RobotStatusContributors>;
 /**
  * Emits the `telemetry-liveness` connectivity signal: whether a heartbeat (from
  * either the new `robot/status` topic or the legacy heartbeat) has been received

package/cjs/services/robot-status/reportedStatus.js

@@ -1,12 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getTelemetryLiveness = exports.getReportedStatusChanges = exports.parseRobotReadiness = exports.parseRobotHealth = exports.LEGACY_HEARTBEAT_SOURCE = exports.ROBOT_STATUS_SOURCE = void 0;
+exports.getTelemetryLiveness = exports.getStatusContributorsChanges = exports.getReportedStatusChanges = exports.parseRobotReadiness = exports.parseRobotHealth = exports.ROBOT_STATUS_CONTRIBUTORS_SOURCE = exports.LEGACY_HEARTBEAT_SOURCE = exports.ROBOT_STATUS_SOURCE = void 0;
 const rxjs_1 = require("rxjs");
 const models_1 = require("../../models");
 /** The new agent topic carrying health + readiness (replaces the heartbeat). */
 exports.ROBOT_STATUS_SOURCE = '/diagnostics/robot/status';
 /** The legacy heartbeat topic — liveness only, no status payload. */
 exports.LEGACY_HEARTBEAT_SOURCE = '/rocos/agent/telemetry/heartbeat';
+/** The per-contributor breakdown behind the reported status (health + readiness). */
+exports.ROBOT_STATUS_CONTRIBUTORS_SOURCE = `${exports.ROBOT_STATUS_SOURCE}/contributors`;
 const DEFAULT_HEARTBEAT_TIMEOUT_MS = 5000;
 const DEFAULT_INTERVAL_MS = 2000;
 /**
@@ -84,6 +86,39 @@ const getReportedStatusChanges = (telemetry, projectId, callsign) => {
     (0, rxjs_1.catchError)(() => (0, rxjs_1.of)({ health: models_1.RobotHealth.UNKNOWN, readiness: models_1.RobotReadiness.UNKNOWN })));
 };
 exports.getReportedStatusChanges = getReportedStatusChanges;
+const toContributor = (raw, parse) => ({
+    id: raw.id ?? '',
+    component: raw.component ?? '',
+    reason: raw.reason ?? '',
+    status: parse(raw.value),
+});
+const EMPTY_CONTRIBUTORS = { health: [], readiness: [] };
+/**
+ * Emits the per-contributor breakdown behind the robot's reported health and
+ * readiness, from the agent's `robot/status/contributors` topic. Each
+ * contributor's integer wire value is mapped onto {@link RobotHealth} /
+ * {@link RobotReadiness}; a missing `health`/`readiness` array becomes `[]`.
+ *
+ * Starts with an empty breakdown so consumers combining this with other streams
+ * emit immediately, and — like {@link getReportedStatusChanges} — a telemetry
+ * error falls back to an empty breakdown rather than terminating the stream.
+ */
+const getStatusContributorsChanges = (telemetry, projectId, callsign) => {
+    return telemetry
+        .subscribe({
+        projectId,
+        callsigns: [callsign],
+        sources: [exports.ROBOT_STATUS_CONTRIBUTORS_SOURCE],
+    })
+        .pipe((0, rxjs_1.map)((message) => {
+        const payload = message.payload ?? {};
+        return {
+            health: (payload.health ?? []).map((c) => toContributor(c, exports.parseRobotHealth)),
+            readiness: (payload.readiness ?? []).map((c) => toContributor(c, exports.parseRobotReadiness)),
+        };
+    }), (0, rxjs_1.startWith)(EMPTY_CONTRIBUTORS), (0, rxjs_1.distinctUntilChanged)((a, b) => JSON.stringify(a) === JSON.stringify(b)), (0, rxjs_1.catchError)(() => (0, rxjs_1.of)(EMPTY_CONTRIBUTORS)));
+};
+exports.getStatusContributorsChanges = getStatusContributorsChanges;
 /**
  * Emits the `telemetry-liveness` connectivity signal: whether a heartbeat (from
  * either the new `robot/status` topic or the legacy heartbeat) has been received

package/esm/api/StreamRegister.d.ts

@@ -1,13 +1,28 @@
 import { IBaseStream } from '../models';
+export interface IAcquiredStream<T extends IBaseStream> {
+    stream: T;
+    isNew: boolean;
+    /** Settles when the stream's one-time init completes; rejects (and evicts) if init fails. */
+    ready: Promise<void>;
+    /** Releases this holder's refcount. One-shot: extra calls are ignored. */
+    release: () => void;
+}
+/**
+ * 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.
+ */
 export declare class StreamRegister {
-    private teleStreams;
+    private entries;
     private logger;
     private static instance;
     private constructor();
     static getInstance(): StreamRegister;
     static getIdentifier($identifier: string, scope?: string): string;
-    addStream(stream: IBaseStream): void;
+    acquireStream<T extends IBaseStream>(identifier: string, create: () => T, init: (stream: T) => Promise<void>): IAcquiredStream<T>;
     getStream(identifier: string): IBaseStream | undefined;
-    removeStream(stream: IBaseStream): void;
     removeAllStreams(): boolean;
+    private release;
+    private evict;
 }

package/esm/api/StreamRegister.js

@@ -1,8 +1,14 @@
 import { RocosError, errorCodes } from '../models';
 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.
+ */
 export class StreamRegister {
     constructor() {
-        this.teleStreams = new Map();
+        this.entries = new Map();
         this.logger = RocosLogger.getInstance('StreamRegister');
     }
     static getInstance() {
@@ -14,55 +20,83 @@ export class StreamRegister {
     static getIdentifier($identifier, scope) {
         return `${$identifier}-${scope ?? ''}`;
     }
-    addStream(stream) {
-        try {
-            // Stop any existing occupant of this key before overwriting it.
-            const existing = this.teleStreams.get(stream.identifier);
-            if (existing && existing !== stream) {
-                existing.stopStream();
-            }
-            this.teleStreams.set(stream.identifier, stream);
+    acquireStream(identifier, create, init) {
+        let entry = this.entries.get(identifier);
+        let isNew = false;
+        if (entry) {
+            entry.refCount++;
         }
-        catch (e) {
-            this.logger.error(`Failed to add stream to list. identifier: ${stream.identifier}`, e);
-            if (e instanceof Error || typeof e === 'string') {
-                throw new RocosError(e, errorCodes.STREAM_LISTENER_ERROR);
-            }
-            else {
-                throw e;
-            }
+        else {
+            isNew = true;
+            const stream = create();
+            const ready = init(stream).catch((error) => {
+                this.logger.error(`Stream init failed, evicting. identifier: ${identifier}`, error);
+                try {
+                    this.evict(identifier, stream);
+                }
+                catch (evictionError) {
+                    this.logger.error(`Failed to evict after init failure. identifier: ${identifier}`, evictionError);
+                }
+                throw error;
+            });
+            // `ready` is stored and shared; this discarded catch pins a rejection observer so an init
+            // failure can never surface as an unhandled rejection, while holders still see the rejection.
+            void ready.catch(() => undefined);
+            entry = { stream, refCount: 1, ready };
+            this.entries.set(identifier, entry);
         }
+        const held = entry;
+        let released = false;
+        const release = () => {
+            // One-shot so a double release can never consume another holder's refcount.
+            if (released)
+                return;
+            released = true;
+            this.release(identifier, held);
+        };
+        return { stream: entry.stream, isNew, ready: entry.ready, release };
     }
     getStream(identifier) {
-        return this.teleStreams.get(identifier);
+        return this.entries.get(identifier)?.stream;
     }
-    removeStream(stream) {
-        try {
-            stream.stopStream();
-            // Only clear the entry if this instance still owns the key: a replacement may already hold it,
-            // and evicting that would leave subscribers forking duplicate streams for the scope.
-            if (this.teleStreams.get(stream.identifier) === stream) {
-                this.teleStreams.delete(stream.identifier);
-            }
-        }
-        catch (e) {
-            this.logger.error(`Failed to remove stream from list. identifier: ${stream.identifier}`, e);
-            if (e instanceof Error || typeof e === 'string') {
-                throw new RocosError(e, errorCodes.STREAM_LISTENER_ERROR);
+    removeAllStreams() {
+        for (const [, entry] of this.entries.entries()) {
+            try {
+                entry.stream.stopStream();
             }
-            else {
-                throw e;
+            catch (e) {
+                this.logger.error(`error removing stream, ${e}`);
             }
         }
+        this.entries.clear();
+        return true;
     }
-    removeAllStreams() {
+    release(identifier, entry) {
+        if (this.entries.get(identifier) !== entry)
+            return; // already evicted, or force-removed
+        entry.refCount--;
+        if (entry.refCount > 0)
+            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(() => {
+            if (this.entries.get(identifier) === entry && entry.refCount <= 0) {
+                this.evict(identifier, entry.stream);
+            }
+        })
+            .catch((e) => this.logger.error(`Failed to evict stream. identifier: ${identifier}`, e));
+    }
+    evict(identifier, stream) {
         try {
-            for (const [, stream] of this.teleStreams.entries()) {
-                this.removeStream(stream);
+            if (this.entries.get(identifier)?.stream === stream) {
+                this.entries.delete(identifier);
             }
+            stream.stopStream();
         }
         catch (e) {
-            this.logger.error(`error removing stream, ${e}`);
+            this.logger.error(`Failed to remove stream from list. identifier: ${identifier}`, e);
             if (e instanceof Error || typeof e === 'string') {
                 throw new RocosError(e, errorCodes.STREAM_LISTENER_ERROR);
             }
@@ -70,6 +104,5 @@ export class StreamRegister {
                 throw e;
             }
         }
-        return true;
     }
 }

package/esm/api/atoms/StreamHeartbeat.js

@@ -35,7 +35,7 @@ export class StreamHeartbeat {
             this.callback = callback;
             this.timeout = timeout;
             this.logger.info('Creating stream heartbeat');
-            this.interval = setInterval(this.callback, this.timeout);
+            this.interval = setInterval(() => this.callback?.(), this.timeout);
         }
         else {
             this.logger.warn('Stream heartbeat already exists');
@@ -55,7 +55,7 @@ export class StreamHeartbeat {
         // if the health check has not started yet, we initialise it
         if (!this.healthInterval) {
             this.logger.debug('Starting health check timer');
-            this.healthInterval = setInterval(this.checkHealth, this.healthTimeout);
+            this.healthInterval = setInterval(() => void this.checkHealth(), this.healthTimeout);
             this.healthLastSeenDate = new Date();
             this.healthMisses = 0;
         }

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

@@ -14,6 +14,7 @@ export declare abstract class TelemetryStreamAbstract implements ITelemetryStrea
     protected token?: string;
     private scope;
     protected url: string;
+    private telemetryActionQueue;
     private timerIntervalInSec;
     protected subscriberStatus: SubscriberStatusEnum;
     private checkerStartedAt?;
@@ -40,10 +41,17 @@ export declare abstract class TelemetryStreamAbstract implements ITelemetryStrea
     stopStream(): void;
     addSubscription(params: ITelemetryParams): void;
     removeSubscription(params: ITelemetryParams, terminateReceiverGroup?: boolean): Promise<void>;
+    private isQueryLookup;
+    private getSubscribedSources;
     sendAcknowledgment(uid: string, status: TelemetryAckStatus, noRetry: boolean): boolean;
     private getSubscriptions;
     protected onData(message: TelemetryStreamMessage, isStream: true): void;
     protected onData(message: TelemetryMessage, isStream: false): void;
+    /**
+     * Gateway subscription state is a set mutated by deltas, so ordering is correctness: a concurrent
+     * unsubscribe landing last strands a subscribe and nothing re-adds it.
+     */
+    private enqueueTelemetryAction;
     private takeTelemetryAction;
     protected listenMessagesAndRenew(): void;
     private addTerminateToAction;
@@ -52,7 +60,6 @@ export declare abstract class TelemetryStreamAbstract implements ITelemetryStrea
      * Auto resubscribe to reduce CPU usage.
      */
     private autoResubscribe;
-    private isFoundCallsign;
     private isFoundSource;
     private isRegisteredMessage;
     private updateReceivedDataStatsWithMessage;

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

@@ -1,16 +1,18 @@
 import { BehaviorSubject, Subject } from 'rxjs';
-import { CallsignsLookup, CallsignsLookupType, RocosTelemetryMessage, StreamOptions, SubscriberStatusEnum, } from '../../../models';
+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 { IDENTIFIER_NAME_TELEMETRY } from '../../../constants/identifier';
 import { RocosStore } from '../../../store/RocosStore';
 import { StreamHeartbeat } from '../../atoms/StreamHeartbeat';
 import { StreamRegister } from '../../StreamRegister';
+import { arrayRemove } from '../../../helpers/arrayRemove';
 import { arrayUnique } from '../../../helpers/arrayUnique';
 import { filter } from 'rxjs/operators';
 import { getSubscriptionsDifference } from '../../../helpers/getSubscriptionsDifference';
 export class TelemetryStreamAbstract {
     constructor(config) {
+        this.telemetryActionQueue = Promise.resolve();
         // /////////////////
         // Subscriber Check
         this.timerIntervalInSec = 1;
@@ -57,27 +59,44 @@ export class TelemetryStreamAbstract {
         }
         this.subscriberStatus = SubscriberStatusEnum.STOPPED;
         this.statusStream$.next(this.subscriberStatus);
+        // The stream is being torn down (the registry only stops a stream when it is evicted), so
+        // complete the status stream: this releases every service-level forwarder subscribed to it
+        // rather than leaving them attached to a dead instance.
+        this.statusStream$.complete();
     }
     addSubscription(params) {
         this.logger.info('Adding subscriptions from stream', params.uniqueId);
         if (!this.subscriptions.has(params.uniqueId)) {
+            const isQuery = this.isQueryLookup();
             // get subscriptions before change
-            const before = this.getSubscriptions();
+            const before = isQuery ? {} : this.getSubscriptions();
             this.subscriptions.set(params.uniqueId, {
                 ...params,
                 count: 1, // set the count to one just in case it's set in param
             });
             // get subscriptions after change
-            const after = this.getSubscriptions();
-            // assign the current values from state after change
-            this.callsignsLookup = new CallsignsLookup(Object.keys(after));
-            this.sources = arrayUnique(Object.values(after).reduce((a, v) => a.concat(v), []));
-            // compare before and after subscriptions and only add the difference
-            const { toAdd } = getSubscriptionsDifference(before, after);
-            // only subscribe if the subscriberId exists, otherwise the messages will be subscribed on lazy load
-            if (toAdd.callsigns.length && toAdd.sources.length) {
-                this.logger.debug('New subscriptions added, we need to refresh sources', { toAdd });
-                void this.takeTelemetryAction('subscribe', new CallsignsLookup(toAdd.callsigns), toAdd.sources);
+            const after = isQuery ? {} : this.getSubscriptions();
+            if (isQuery) {
+                // A query stream selects its callsigns server-side, so the callsign-keyed view above holds
+                // nothing for it: keep the query and diff on sources alone.
+                const sourcesBefore = this.sources;
+                this.sources = this.getSubscribedSources();
+                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);
+                }
+            }
+            else {
+                // assign the current values from state after change
+                this.callsignsLookup = new CallsignsLookup(Object.keys(after));
+                this.sources = arrayUnique(Object.values(after).reduce((a, v) => a.concat(v), []));
+                // compare before and after subscriptions and only add the difference
+                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);
+                }
             }
         }
         else {
@@ -97,16 +116,24 @@ export class TelemetryStreamAbstract {
         if (subs.count)
             return;
         this.logger.info('Removing subscriptions from stream registry', params.uniqueId);
-        const before = this.getSubscriptions();
+        const isQuery = this.isQueryLookup();
+        const before = isQuery ? {} : this.getSubscriptions();
         this.subscriptions.delete(params.uniqueId);
-        const after = this.getSubscriptions();
-        // Do this before we send the telemetry request so that new subscriptions don't get this stream from the register while it is closing
-        if (!this.subscriptions.size) {
-            this.logger.info('No subscriptions remaining closing stream', params.uniqueId);
-            this.stopStream();
-            // self remove when no subscriptions are left
-            StreamRegister.getInstance().removeStream(this);
-            this.logger.info('Stream closed');
+        const after = isQuery ? {} : this.getSubscriptions();
+        if (isQuery) {
+            const sourcesBefore = this.sources;
+            this.sources = this.getSubscribedSources();
+            const toRemove = arrayRemove(sourcesBefore, this.sources);
+            if (toRemove.length) {
+                this.logger.debug('Query subscriptions removed, we need to refresh sources', { toRemove });
+                try {
+                    await this.enqueueTelemetryAction('unsubscribe', this.callsignsLookup, toRemove, terminateReceiverGroup);
+                }
+                catch (err) {
+                    this.logger.error(`Failed to unsubscribe: ${err}`);
+                }
+            }
+            return;
         }
         // assign the current values from state after change
         this.callsignsLookup = new CallsignsLookup(Object.keys(after));
@@ -115,13 +142,23 @@ export class TelemetryStreamAbstract {
         if (toRemove.callsigns.length && toRemove.sources.length) {
             this.logger.debug('Subscriptions removed, we need to refresh sources', { toRemove });
             try {
-                await this.takeTelemetryAction('unsubscribe', new CallsignsLookup(toRemove.callsigns), toRemove.sources, terminateReceiverGroup);
+                await this.enqueueTelemetryAction('unsubscribe', new CallsignsLookup(toRemove.callsigns), toRemove.sources, terminateReceiverGroup);
             }
             catch (err) {
                 this.logger.error(`Failed to unsubscribe: ${err}`);
             }
         }
     }
+    isQueryLookup() {
+        return this.callsignsLookup?.isQuery() ?? false;
+    }
+    getSubscribedSources() {
+        const sources = [];
+        this.subscriptions.forEach((data) => {
+            sources.push(...data.sources);
+        });
+        return arrayUnique(sources);
+    }
     sendAcknowledgment(uid, status, noRetry) {
         return this.sendAcknowledgmentInternal(uid, status, noRetry);
     }
@@ -171,8 +208,8 @@ export class TelemetryStreamAbstract {
                 this.subscriberId = subscriberId;
                 rocosMessage.subscriberId = this.subscriberId;
                 this.logger.info('onData', `subscriberId has been updated - ${subscriberId}`, { subscriberId });
-                void this.takeTelemetryAction('subscribe');
-                this.heartbeat.start(this.sendHeartbeat, this.sendHeartbeatTime);
+                void this.enqueueTelemetryAction('subscribe');
+                this.heartbeat.start(() => this.sendHeartbeat(), this.sendHeartbeatTime);
                 isRobotMessage = false;
                 break;
             }
@@ -208,25 +245,40 @@ export class TelemetryStreamAbstract {
             });
         }
     }
+    /**
+     * Gateway subscription state is a set mutated by deltas, so ordering is correctness: a concurrent
+     * 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;
+    }
     async takeTelemetryAction(actionType, callsignsLookup, sources, terminate) {
         this.logger.debug('takeTelemetryAction', actionType);
-        if (!this.subscriberId || !this.projectId) {
-            this.logger.debug('takeTelemetryAction', actionType, `${actionType} without subscriberId or projectId - message will not send out`, {
-                subscriberId: this.subscriberId,
-                projectId: this.projectId,
-            });
+        // 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) {
+            // 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();
         }
         const actionSources = sources ?? this.sources;
         const actionCallsigns = callsignsLookup ?? this.callsignsLookup;
-        if (this.callsignsLookup.lookupType === CallsignsLookupType.List) {
+        if (!actionCallsigns.isQuery()) {
             // Compose the request message
             const req = TelemetryRequest.create({
                 subscriberId: this.subscriberId,
                 requestedActions: [
                     {
                         operation: actionType,
-                        callsigns: actionCallsigns.lookupValue,
+                        callsigns: actionCallsigns.getCallsigns(),
                         sources: actionSources,
                     },
                 ],
@@ -238,12 +290,12 @@ export class TelemetryStreamAbstract {
             // Send the message to back-end.
             return this.requestTelemetry(req);
         }
-        else if (actionCallsigns.lookupType === CallsignsLookupType.Query) {
-            const lookupValue = actionCallsigns.lookupValue;
+        const query = actionCallsigns.getQuery();
+        if (query) {
             // We don't support nested query at the moment
             const queryOrPredicatesList = [];
             // Loop through user provided predicates to construct a telemetry query request
-            lookupValue.predicates.forEach((callsignsPredicate) => {
+            query.predicates.forEach((callsignsPredicate) => {
                 const queryOrPredicate = QueryOrPredicate.create({
                     content: {
                         oneofKind: 'predicate',
@@ -262,7 +314,7 @@ export class TelemetryStreamAbstract {
                 sources: actionSources,
                 operation: actionType,
                 callsignQuery: {
-                    operation: lookupValue.operation.valueOf(),
+                    operation: query.operation.valueOf(),
                     queryOrPredicates: queryOrPredicatesList,
                 },
             });
@@ -379,16 +431,11 @@ export class TelemetryStreamAbstract {
         this.lastRobotMessageReceived = undefined;
         this.registerReceiver();
     }
-    isFoundCallsign(callsign) {
-        return this.callsignsLookup.lookupType === CallsignsLookupType.List
-            ? this.callsignsLookup.lookupValue.indexOf(callsign) !== -1
-            : true; // If callsigns lookup option is query, we always return true
-    }
     isFoundSource(source) {
         return this.sources.indexOf(source) !== -1;
     }
     isRegisteredMessage(callsign, source) {
-        return this.isFoundCallsign(callsign) && this.isFoundSource(source);
+        return this.callsignsLookup.includesCallsign(callsign) && this.isFoundSource(source);
     }
     updateReceivedDataStatsWithMessage(msg) {
         const { source } = msg;

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

@@ -1,7 +1,7 @@
 import { AddIceCandidateRequest, GetDetailsRequest, OfferRequest, OperatorConnectRequest, } from '../../../grpc/pigeon_pb';
 import { SubscriberStatusEnum, } from '../../../models';
 import { BehaviorSubject } from 'rxjs';
-import { IDENTIFIER_NAME_COMMAND } from '../../../constants/identifier';
+import { IDENTIFIER_NAME_WEBRTC_SIGNALLING } from '../../../constants/identifier';
 import { RocosStore } from '../../../store/RocosStore';
 import { StreamRegister } from '../../StreamRegister';
 import { filter } from 'rxjs/operators';
@@ -9,7 +9,7 @@ export class WebRTCSignallingStreamAbstract {
     constructor(config) {
         this.subscriberStatus = SubscriberStatusEnum.STOPPED;
         this.scope = config.scope;
-        this.identifier = StreamRegister.getIdentifier(IDENTIFIER_NAME_COMMAND, this.scope);
+        this.identifier = StreamRegister.getIdentifier(IDENTIFIER_NAME_WEBRTC_SIGNALLING, this.scope);
         this.token = config.token;
         this.url = config.url;
         this.statusStream$ = new BehaviorSubject(SubscriberStatusEnum.STOPPED);