@blueyerobotics/blueye-ts 4.0.4 → 5.0.0

package/README.md

@@ -56,12 +56,49 @@ The derived `client.state` reflects the aggregate of the core sockets (`sub`, `r
 - `connecting`: one or more required sockets are not yet ready.
 - `connected`: all required sockets are ready — safe to call `sendRequest()`, `getTelemetry()`, and `sendControl()`.
 
-`client.sonarState` reflects the sonar socket independently. If the client loses one or more sockets after being connected, the derived state moves back to `connecting`. `sendRequest()` and `sendControl()` reject unless the client is in the `connected` state.
+All state events — global and per-socket — are edge-triggered: they fire exactly once per actual change. If the client loses one or more sockets after being connected, the derived state moves back to `connecting` (with a `connecting` event). `sendRequest()` and `sendControl()` reject unless the client is in the `connected` state.
+
+### Telemetry staleness watchdog
+
+A dead link does not always produce a close event — a tether or radio drop can leave the sockets looking connected while telemetry silently freezes, until TCP retransmission gives up minutes later. Because the drone publishes telemetry continuously (e.g. `DroneTimeTel` at 1 Hz), the client watches for it: if no message arrives on the telemetry socket for `stalenessTimeout` milliseconds (default `5000`) while `connected`, the client force-drops its connections. This converts the silent failure into the normal loss path — consumers see the usual `connecting` event, and the built-in reconnect loop restores the session when the link returns.
+
+The watchdog only arms after the first telemetry message of a connection (a connection that never produced telemetry is not judged stale), watches the main telemetry socket only (sonar can be legitimately quiet), and disarms on `disconnect()`. Set `stalenessTimeout: 0` to disable it:
+
+```ts
+const client = new BlueyeClient({ stalenessTimeout: 0 }); // no watchdog
+```
+
+## Transports
+
+`BlueyeClient` talks to its sockets through a small transport interface. The default adapter uses [jszmq](https://github.com/BluEye-Robotics/jszmq) over WebSockets; an in-memory adapter ships alongside it for tests, so application code using `BlueyeClient` can be exercised without a drone or any network:
+
+```ts
+import { BlueyeClient, InMemoryTransport } from "@blueyerobotics/blueye-ts";
+
+const transport = new InMemoryTransport();
+const rpc = transport.listen("mem://rpc");
+rpc.onMessage(([topic, payload], reply) => {
+  // inspect the request, reply([topic, encoded]) as the drone would
+});
+transport.listen("mem://sub");
+transport.listen("mem://pub");
+transport.listen("mem://sonar");
+
+const client = new BlueyeClient({
+  subUrl: "mem://sub",
+  rpcUrl: "mem://rpc",
+  pubUrl: "mem://pub",
+  sonarUrl: "mem://sonar",
+  transport,
+});
+```
+
+When you are done with a client, call `client.close()` to release the underlying sockets permanently; a closed client cannot be reused.
 
 ## Sonar support
 
 `BlueyeClient` connects the sonar websocket endpoint at `ws://192.168.1.101:9988` when a supported multibeam device is detected in a `DroneInfoTel` message.
 
-- On `connect()`, the sonar socket subscribes but only connects when a known multibeam device ID is found in the guest-port device list.
-- Once detected, the sonar socket connects and the global `connected` state requires it to be ready.
+- On `connect()`, the sonar socket subscribes but only connects when a known multibeam device ID is found in the guest-port device list. Detection inspects every `DroneInfoTel` — one is requested over RPC when the connection comes up, and any later `DroneInfoTel` arriving over SUB is also considered.
+- Once detected, the sonar socket connects and the global `connected` state requires it to be ready. Detection resets on `disconnect()`; the next connection starts without requiring sonar until it is detected again.
 - Sonar telemetry such as `MultibeamPingTel`, `MultibeamConfigTel`, and `MultibeamDiscoveryTel` is emitted through the same typed event interface as other telemetry messages.

package/dist/index.d.ts

@@ -1,4 +1,7 @@
 export { blueye, google } from "@blueyerobotics/protocol-definitions";
 export * from "./src/binlog-parser";
 export * from "./src/client";
-export * from "./src/schema";
+export * from "./src/in-memory-transport";
+export * from "./src/protocol";
+export * from "./src/sonar-device";
+export * from "./src/transport";

package/dist/index.js

@@ -1,4 +1,7 @@
 export { blueye, google } from "@blueyerobotics/protocol-definitions";
 export * from "./src/binlog-parser";
 export * from "./src/client";
-export * from "./src/schema";
+export * from "./src/in-memory-transport";
+export * from "./src/protocol";
+export * from "./src/sonar-device";
+export * from "./src/transport";

package/dist/src/binlog-parser.d.ts

@@ -1,4 +1,4 @@
-import { type Protocol, type ProtocolKey, type ProtocolType } from "./client";
+import { type Protocol, type ProtocolKey, type ProtocolType } from "./protocol";
 export type Message = {
     [K in ProtocolKey]: {
         monotonicTime: number;

package/dist/src/binlog-parser.js

@@ -1,7 +1,7 @@
 import { blueye } from "@blueyerobotics/protocol-definitions";
 import { BinaryReader } from "@bufbuild/protobuf/wire";
 import { Gunzip } from "fflate";
-import { isInProtocol, } from "./client";
+import { decodeMessage, isInProtocol, protocolTypeOf, topicToKey, } from "./protocol";
 /**
  * Parse a binlog file from raw (gzipped) data into structured messages..
  * @param rawData The raw binary data of the binlog file (gzip format).
@@ -69,35 +69,31 @@ export const parseMessages = (decompressed, fixTimes = true) => {
         const msgBytes = decompressed.buffer.slice(start, end);
         reader.pos = end;
         const msg = blueye.protocol.BinlogRecord.decode(new Uint8Array(msgBytes), length);
-        const key = msg.payload?.typeUrl.split(".").at(-1);
-        if (!key || !isInProtocol(key)) {
-            console.warn(`Unknown protocol key: ${key}`);
+        if (msg.payload == null) {
+            console.warn("Missing payload in BinlogRecord");
             continue;
         }
-        if (msg.payload == null) {
-            console.warn(`Missing payload for key: ${key}`);
+        const key = topicToKey(msg.payload.typeUrl);
+        if (!isInProtocol(key)) {
+            console.warn(`Unknown protocol key: ${key}`);
             continue;
         }
-        const data = blueye.protocol[key].decode(msg.payload.value);
+        const data = decodeMessage(key, msg.payload.value);
         let innerData;
         if (key === "GetTelemetryRep") {
             const telRep = data;
-            const innerKey = telRep.payload?.typeUrl.split(".").at(-1);
-            if (!innerKey || !isInProtocol(innerKey)) {
+            if (telRep.payload == null) {
+                console.warn("Missing inner payload in GetTelemetryRep");
+                continue;
+            }
+            const innerKey = topicToKey(telRep.payload.typeUrl);
+            if (!isInProtocol(innerKey)) {
                 console.warn(`Unknown inner protocol key: ${innerKey}`);
                 continue;
             }
-            innerData = telRep.payload
-                ? blueye.protocol[innerKey].decode(telRep.payload.value)
-                : undefined;
+            innerData = decodeMessage(innerKey, telRep.payload.value);
         }
-        let type = "Tel";
-        if (key.endsWith("Ctrl"))
-            type = "Ctrl";
-        else if (key.endsWith("Rep"))
-            type = "Rep";
-        else if (key.endsWith("Req"))
-            type = "Req";
+        const type = protocolTypeOf(key);
         messages.push({
             monotonicTime: msg.clockMonotonic?.getTime() ?? 0,
             time: msg.unixTimestamp?.getTime() ?? 0,

package/dist/src/client.d.ts

@@ -1,29 +1,16 @@
-import { blueye } from "@blueyerobotics/protocol-definitions";
 import { type LogLevel } from "consola";
 import { Emitter } from "strict-event-emitter";
-export declare const MULTIBEAM_DEVICE_IDS: number[];
-export type Protocol = typeof blueye.protocol;
-export type ProtocolType = "Req" | "Rep" | "Tel" | "Ctrl";
-export type ProtocolKey = Extract<keyof Protocol, `${string}${ProtocolType}`>;
-export type Req = keyof Pick<Protocol, Extract<ProtocolKey, `${string}Req`>>;
-export type Rep = keyof Pick<Protocol, Extract<ProtocolKey, `${string}Rep`>>;
-export type Tel = keyof Pick<Protocol, Extract<ProtocolKey, `${string}Tel`>>;
-export type Ctrl = keyof Pick<Protocol, Extract<ProtocolKey, `${string}Ctrl`>>;
-export type ReqToRep<T extends Req> = T extends `${infer Prefix}Req` ? `${Prefix}Rep` extends ProtocolKey ? Protocol[`${Prefix}Rep`] : never : never;
-export type MsgHandler<T extends Req | Ctrl> = Protocol[T];
-export type CreateArgs<T extends Req | Ctrl> = Parameters<MsgHandler<T>["create"]>[0];
-export type DecodedOutput<T extends Req> = ReturnType<ReqToRep<T>["decode"]>;
-export type DecodedTelOutput<T extends Tel> = ReturnType<Protocol[T]["decode"]>;
-type State = "connecting" | "connected" | "disconnected";
-export type SocketName = "sub" | "rpc" | "pub" | "sonar";
+import { type ConnectionState, type SocketName } from "./connection-state";
+import { type CreateArgs, type Ctrl, type DecodedOutput, type DecodedTelOutput, type Req, type Tel } from "./protocol";
+import { type Transport } from "./transport";
+export type { ConnectionState, SocketName } from "./connection-state";
 export type Events = {
-    [K in State]: [];
+    [K in ConnectionState]: [];
 } & {
-    [K in `${SocketName}-${State}`]: [];
+    [K in `${SocketName}-${ConnectionState}`]: [];
 } & {
     [K in Tel]: [DecodedTelOutput<K>];
 };
-export declare const isInProtocol: (key: string) => key is keyof typeof blueye.protocol;
 type Options = Partial<{
     subUrl: string;
     rpcUrl: string;
@@ -31,12 +18,15 @@ type Options = Partial<{
     sonarUrl: string;
     timeout: number;
     reconnectInterval: number;
+    stalenessTimeout: number;
     logLevel: LogLevel;
     autoConnect: boolean;
+    transport: Transport;
 }>;
 export declare class BlueyeClient extends Emitter<Events> {
     timeout: number;
     reconnectInterval: number;
+    stalenessTimeout: number;
     private subUrl;
     private rpcUrl;
     private pubUrl;
@@ -45,22 +35,32 @@ export declare class BlueyeClient extends Emitter<Events> {
     private rpc;
     private pub;
     private sonarSub;
-    private queue;
+    private pipeline;
     private logger;
-    private shouldBeConnected;
-    private isSonarDetected;
-    private socketState;
-    constructor({ subUrl, rpcUrl, pubUrl, sonarUrl, timeout, reconnectInterval, logLevel, autoConnect, }?: Options);
-    get state(): State;
-    private updateSocketState;
+    private tracker;
+    private sonarIncompatibilityWarned;
+    private lastSubMessageAt;
+    private stalenessTimer;
+    constructor({ subUrl, rpcUrl, pubUrl, sonarUrl, timeout, reconnectInterval, stalenessTimeout, logLevel, autoConnect, transport, }?: Options);
+    get state(): ConnectionState;
+    private applyTransitions;
     private handleTelemetryMessage;
     private bindSocketLifecycle;
     private ensureConnected;
+    private startStalenessWatchdog;
+    private stopStalenessWatchdog;
+    private checkTelemetryStaleness;
+    private primeSonarDetection;
+    private evaluateSonarDetection;
     connect(): void;
     disconnect(): void;
+    /**
+     * Permanently close all sockets and release their resources. The client
+     * cannot be reused afterwards — create a new instance to reconnect.
+     */
+    close(): void;
     sendRequest<T extends Req>(req: T, opts?: CreateArgs<T>): Promise<DecodedOutput<T> | null>;
     getTelemetry<T extends Tel>(type: T): Promise<DecodedTelOutput<T>>;
     waitForTelemetry<T extends Tel>(type: T, timeout?: number | null): Promise<DecodedTelOutput<T>>;
     sendControl<T extends Ctrl>(ctrl: T, opts?: CreateArgs<T>): Promise<void>;
 }
-export {};

package/dist/src/client.js

@@ -1,27 +1,18 @@
-import { Pub as ZMQPub, Req as ZMQRep, Sub as ZMQSub, } from "@blueyerobotics/jszmq";
-import { blueye } from "@blueyerobotics/protocol-definitions";
 import { createConsola, LogLevels, } from "consola";
-import * as semver from "semver";
 import { Emitter } from "strict-event-emitter";
-import { AsyncQueue } from "./async-queue";
-import { responseSchema, telemetrySchema } from "./schema";
+import { ConnectionTracker, } from "./connection-state";
+import { decodeMessage, encodeMessage, isCtrl, isRep, isReq, isTel, keyToTopic, topicToKey, } from "./protocol";
+import { RequestPipeline } from "./request-pipeline";
+import { detectSonar } from "./sonar-device";
+import { JszmqTransport, } from "./transport";
 const DEFAULT_SUB_URL = "ws://192.168.1.101:9985";
 const DEFAULT_RPC_URL = "ws://192.168.1.101:9986";
 const DEFAULT_PUB_URL = "ws://192.168.1.101:9987";
 const DEFAULT_SONAR_URL = "ws://192.168.1.101:9988";
-export const MULTIBEAM_DEVICE_IDS = [13, 16, 18, 20, 29, 30, 41, 42];
-export const isInProtocol = (key) => {
-    return key in blueye.protocol;
-};
-const hasSonarEndpoint = (version) => {
-    const coercedVersion = semver.coerce(version);
-    return coercedVersion
-        ? semver.satisfies(coercedVersion, ">=4.7.0") || version.endsWith("-dev")
-        : false;
-};
 export class BlueyeClient extends Emitter {
     timeout;
     reconnectInterval;
+    stalenessTimeout;
     subUrl;
     rpcUrl;
     pubUrl;
@@ -30,29 +21,26 @@ export class BlueyeClient extends Emitter {
     rpc;
     pub;
     sonarSub;
-    queue;
+    pipeline;
     logger;
-    shouldBeConnected = false;
-    isSonarDetected = false;
-    socketState = {
-        sub: "disconnected",
-        rpc: "disconnected",
-        pub: "disconnected",
-        sonar: "disconnected",
-    };
-    constructor({ subUrl = DEFAULT_SUB_URL, rpcUrl = DEFAULT_RPC_URL, pubUrl = DEFAULT_PUB_URL, sonarUrl = DEFAULT_SONAR_URL, timeout = 2000, reconnectInterval = 2000, logLevel = LogLevels.info, autoConnect = false, } = {}) {
+    tracker = new ConnectionTracker();
+    sonarIncompatibilityWarned = false;
+    lastSubMessageAt = null;
+    stalenessTimer = null;
+    constructor({ subUrl = DEFAULT_SUB_URL, rpcUrl = DEFAULT_RPC_URL, pubUrl = DEFAULT_PUB_URL, sonarUrl = DEFAULT_SONAR_URL, timeout = 2000, reconnectInterval = 2000, stalenessTimeout = 5000, logLevel = LogLevels.info, autoConnect = false, transport = new JszmqTransport(), } = {}) {
         super();
         this.timeout = timeout;
         this.reconnectInterval = reconnectInterval;
+        this.stalenessTimeout = stalenessTimeout;
         this.subUrl = subUrl;
         this.rpcUrl = rpcUrl;
         this.pubUrl = pubUrl;
         this.sonarUrl = sonarUrl;
-        this.sub = new ZMQSub();
-        this.rpc = new ZMQRep();
-        this.pub = new ZMQPub();
-        this.sonarSub = new ZMQSub();
-        this.queue = new AsyncQueue();
+        this.sub = transport.createSocket("sub");
+        this.rpc = transport.createSocket("req");
+        this.pub = transport.createSocket("pub");
+        this.sonarSub = transport.createSocket("sub");
+        this.pipeline = new RequestPipeline(this.rpc);
         this.logger = createConsola({
             level: logLevel,
             formatOptions: { colors: true, compact: false },
@@ -62,104 +50,139 @@ export class BlueyeClient extends Emitter {
         this.bindSocketLifecycle("pub", this.pub);
         this.bindSocketLifecycle("sonar", this.sonarSub);
         this.sub.on("message", (topic, msg) => {
+            this.lastSubMessageAt = Date.now();
             this.handleTelemetryMessage("sub", topic, msg);
         });
         this.sonarSub.on("message", (topic, msg) => {
             this.handleTelemetryMessage("sonar", topic, msg);
         });
-        this.emit(this.state);
+        // Any DroneInfoTel — whether primed via RPC on connect or arriving over
+        // SUB later — can reveal a multibeam sonar.
+        this.on("DroneInfoTel", (msg) => {
+            this.evaluateSonarDetection(msg);
+        });
         this.logger.info(`[client] ${this.state}`);
         if (autoConnect) {
             this.connect();
         }
     }
     get state() {
-        if (!this.shouldBeConnected)
-            return "disconnected";
-        const { sub, rpc, pub } = this.socketState;
-        if (sub === "connected" &&
-            rpc === "connected" &&
-            pub === "connected" &&
-            (this.isSonarDetected ? this.socketState.sonar === "connected" : true)) {
-            return "connected";
-        }
-        return "connecting";
+        return this.tracker.state;
     }
-    updateSocketState(name, newState) {
-        if (this.socketState[name] === newState) {
-            return;
-        }
-        const oldState = this.state;
-        this.socketState[name] = newState;
-        this.logger.info(`[${name}] ${newState}`);
-        this.emit(`${name}-${newState}`);
-        // If all sockets are connected, emit "connected"
-        this.emit(this.state);
-        if (oldState !== this.state) {
-            this.logger.info(`[client] ${this.state}`);
+    applyTransitions(transitions) {
+        for (const transition of transitions) {
+            if (transition.scope === "socket") {
+                this.logger.info(`[${transition.name}] ${transition.state}`);
+                this.emit(`${transition.name}-${transition.state}`);
+            }
+            else {
+                // Any client-state change invalidates the staleness baseline: after
+                // a loss and reconnect the watchdog must only judge telemetry
+                // received on the new connection, never a pre-outage timestamp.
+                this.lastSubMessageAt = null;
+                this.logger.info(`[client] ${transition.state}`);
+                this.emit(transition.state);
+            }
         }
     }
     handleTelemetryMessage(socketName, topic, msg) {
-        const { key, data } = responseSchema.parse({ key: topic, data: msg });
-        if (!isInProtocol(key) || !key.endsWith("Tel")) {
+        const key = topicToKey(topic);
+        if (!isTel(key)) {
             this.logger.warn(`[${socketName}] unknown protocol:`, key);
             return;
         }
-        const protocol = blueye.protocol[key];
-        const message = protocol.decode(data);
+        const message = decodeMessage(key, msg);
         this.logger.verbose(`[${socketName}] message:`, key, message);
         this.emit(key, message);
     }
     bindSocketLifecycle(name, socket) {
         socket.on("ready", () => {
-            if (!this.shouldBeConnected)
-                return;
-            this.updateSocketState(name, "connected");
+            this.applyTransitions(this.tracker.socketReady(name));
         });
         socket.on("lost", () => {
-            if (!this.shouldBeConnected)
-                return;
-            this.updateSocketState(name, "connecting");
+            this.applyTransitions(this.tracker.socketLost(name));
         });
     }
     ensureConnected(operation) {
-        if (this.socketState[operation] !== "connected") {
+        if (this.state !== "connected") {
             throw new Error(`[client] cannot send ${operation} while ${this.state}; call connect() and wait for "connected"`);
         }
     }
-    connect() {
-        if (this.shouldBeConnected) {
-            this.logger.warn("[client] already connecting or connected");
+    startStalenessWatchdog() {
+        this.stopStalenessWatchdog();
+        if (this.stalenessTimeout <= 0)
             return;
+        const checkInterval = Math.max(100, Math.floor(this.stalenessTimeout / 4));
+        this.stalenessTimer = setInterval(() => {
+            this.checkTelemetryStaleness();
+        }, checkInterval);
+    }
+    stopStalenessWatchdog() {
+        if (this.stalenessTimer != null) {
+            clearInterval(this.stalenessTimer);
+            this.stalenessTimer = null;
         }
-        this.once("connected", async () => {
-            const msg = await this.waitForTelemetry("DroneInfoTel");
-            const version = msg.droneInfo?.blunuxVersion;
-            if (!hasSonarEndpoint(version ?? "")) {
-                this.logger.warn(`[sonar] incompatible Blunux version detected in DroneInfoTel: ${version}; sonar telemetry may not be available`);
-                return;
-            }
-            const devices = [
-                ...(msg.droneInfo?.gp?.gp1?.deviceList?.devices ?? []),
-                ...(msg.droneInfo?.gp?.gp2?.deviceList?.devices ?? []),
-                ...(msg.droneInfo?.gp?.gp3?.deviceList?.devices ?? []),
-            ].map((device) => device.deviceId);
-            if (devices.some((deviceId) => MULTIBEAM_DEVICE_IDS.includes(deviceId))) {
-                this.logger.info("[sonar] multibeam device detected in DroneInfoTel");
-                this.isSonarDetected = true;
-                this.sonarSub.connect(this.sonarUrl);
+    }
+    checkTelemetryStaleness() {
+        // Only armed while connected AND after telemetry has actually flowed —
+        // a connection that never produced telemetry is not judged stale.
+        if (this.state !== "connected" || this.lastSubMessageAt == null)
+            return;
+        const silentFor = Date.now() - this.lastSubMessageAt;
+        if (silentFor <= this.stalenessTimeout)
+            return;
+        this.logger.warn(`[watchdog] no telemetry for ${silentFor}ms; dropping connections to force a reconnect`);
+        // Re-arm only once telemetry flows again, so a live-but-quiet server
+        // doesn't get dropped in a loop.
+        this.lastSubMessageAt = null;
+        // Convert the silent failure into the explicit loss the state machine
+        // already handles: sockets emit "lost" and their reconnect loop runs.
+        this.sub.dropConnection();
+        this.rpc.dropConnection();
+        this.pub.dropConnection();
+        this.sonarSub.dropConnection();
+    }
+    // Bound so disconnect() can remove it if the connection never came up
+    primeSonarDetection = async () => {
+        try {
+            const msg = await this.getTelemetry("DroneInfoTel");
+            this.evaluateSonarDetection(msg);
+        }
+        catch (error) {
+            this.logger.trace("[sonar] failed to get DroneInfoTel via RPC; waiting for SUB telemetry:", error);
+        }
+    };
+    evaluateSonarDetection(msg) {
+        if (!this.tracker.intended || this.tracker.isSonarRequired)
+            return;
+        const detection = detectSonar(msg);
+        if (!detection.detected) {
+            if (detection.reason === "incompatible-firmware" &&
+                !this.sonarIncompatibilityWarned) {
+                this.sonarIncompatibilityWarned = true;
+                this.logger.warn(`[sonar] incompatible Blunux version detected in DroneInfoTel: ${detection.version}; sonar telemetry may not be available`);
             }
-        });
-        this.sub.options.reconnectInterval = this.reconnectInterval;
-        this.rpc.options.reconnectInterval = this.reconnectInterval;
-        this.pub.options.reconnectInterval = this.reconnectInterval;
-        this.sonarSub.options.reconnectInterval = this.reconnectInterval;
-        this.shouldBeConnected = true;
-        for (const name of ["sub", "rpc", "pub"]) {
-            this.updateSocketState(name, "connecting");
+            return;
         }
-        this.logger.info(`[client] ${this.state}`);
-        this.emit(this.state);
+        this.logger.info(`[sonar] multibeam device detected in DroneInfoTel (deviceId: ${detection.deviceId})`);
+        const transitions = this.tracker.sonarDetected();
+        this.sonarSub.connect(this.sonarUrl);
+        this.applyTransitions(transitions);
+    }
+    connect() {
+        if (this.tracker.intended) {
+            this.logger.warn("[client] already connecting or connected");
+            return;
+        }
+        this.sonarIncompatibilityWarned = false;
+        this.lastSubMessageAt = null;
+        this.startStalenessWatchdog();
+        this.once("connected", this.primeSonarDetection);
+        this.sub.setReconnectInterval(this.reconnectInterval);
+        this.rpc.setReconnectInterval(this.reconnectInterval);
+        this.pub.setReconnectInterval(this.reconnectInterval);
+        this.sonarSub.setReconnectInterval(this.reconnectInterval);
+        this.applyTransitions(this.tracker.connectRequested());
         this.sub.subscribe("");
         this.sub.connect(this.subUrl);
         this.rpc.connect(this.rpcUrl);
@@ -167,51 +190,49 @@ export class BlueyeClient extends Emitter {
         this.sonarSub.subscribe("");
     }
     disconnect() {
-        if (!this.shouldBeConnected) {
+        if (!this.tracker.intended) {
             this.logger.warn("[client] already disconnected");
             return;
         }
-        this.shouldBeConnected = false;
+        this.stopStalenessWatchdog();
+        this.off("connected", this.primeSonarDetection);
         this.sub.unsubscribe("");
         this.sub.disconnect(this.subUrl);
         this.rpc.disconnect(this.rpcUrl);
         this.pub.disconnect(this.pubUrl);
         this.sonarSub.unsubscribe("");
         this.sonarSub.disconnect(this.sonarUrl);
-        for (const name of ["sub", "rpc", "pub", "sonar"]) {
-            this.updateSocketState(name, "disconnected");
+        this.applyTransitions(this.tracker.disconnectRequested());
+    }
+    /**
+     * Permanently close all sockets and release their resources. The client
+     * cannot be reused afterwards — create a new instance to reconnect.
+     */
+    close() {
+        if (this.tracker.intended) {
+            this.disconnect();
         }
+        this.stopStalenessWatchdog();
+        this.sub.close();
+        this.rpc.close();
+        this.pub.close();
+        this.sonarSub.close();
     }
     async sendRequest(req, opts = {}) {
         this.ensureConnected("rpc");
-        if (!isInProtocol(req) || !req.endsWith("Req")) {
+        if (!isReq(req)) {
             throw new Error(`[rpc] unknown protocol: ${req}`);
         }
-        const protocol = blueye.protocol[req];
-        const message = protocol.create(opts);
-        const encoded = protocol.encode(message).finish();
-        const request = () => {
-            return new Promise((resolve, reject) => {
-                const timer = setTimeout(() => reject(new Error("[rpc] request timed out")), this.timeout);
-                this.rpc.once("message", (topic, msg) => {
-                    clearTimeout(timer);
-                    resolve({
-                        key: new TextDecoder().decode(topic).split(".").at(-1) ?? "",
-                        data: msg,
-                    });
-                });
-                this.rpc.send([`blueye.protocol.${req}`, encoded]);
-            });
-        };
-        const { key, data } = await this.queue.enqueue(request);
+        const encoded = encodeMessage(req, opts);
+        const [topic, data] = await this.pipeline.request([keyToTopic(req), encoded], this.timeout);
+        const key = topicToKey(topic);
         if (key === "Empty") {
             return null;
         }
-        if (!isInProtocol(key) || !key.endsWith("Rep")) {
+        if (!isRep(key)) {
             throw new Error(`[rpc] unknown response protocol: ${key}`);
         }
-        const rep = blueye.protocol[key];
-        const result = rep.decode(data);
+        const result = decodeMessage(key, data);
         this.logger.debug("[rpc] decoded:", result);
         return result;
     }
@@ -222,12 +243,14 @@ export class BlueyeClient extends Emitter {
         if (!response) {
             throw new Error(`[rpc] no response for telemetry request: ${type}`);
         }
-        const { payload } = telemetrySchema.parse(response);
-        const { typeUrl, value } = payload;
-        if (!isInProtocol(typeUrl) || !typeUrl.endsWith("Tel")) {
-            throw new Error(`[rpc] unknown telemetry typeUrl: ${typeUrl}`);
+        if (!response.payload) {
+            throw new Error(`[rpc] no cached telemetry available for: ${type}`);
+        }
+        const key = topicToKey(response.payload.typeUrl);
+        if (!isTel(key)) {
+            throw new Error(`[rpc] unknown telemetry typeUrl: ${key}`);
         }
-        const result = blueye.protocol[typeUrl].decode(value);
+        const result = decodeMessage(key, response.payload.value);
         this.logger.debug("[rpc] result:", result);
         return result;
     }
@@ -258,13 +281,11 @@ export class BlueyeClient extends Emitter {
     }
     async sendControl(ctrl, opts = {}) {
         this.ensureConnected("pub");
-        if (!isInProtocol(ctrl) || !ctrl.endsWith("Ctrl")) {
+        if (!isCtrl(ctrl)) {
             throw new Error(`[pub] unknown protocol: ${ctrl}`);
         }
-        const protocol = blueye.protocol[ctrl];
-        const message = protocol.create(opts);
-        const encoded = protocol.encode(message).finish();
-        this.logger.debug("[pub] sending control:", ctrl, message);
-        this.pub.send([`blueye.protocol.${ctrl}`, encoded]);
+        const encoded = encodeMessage(ctrl, opts);
+        this.logger.debug("[pub] sending control:", ctrl, opts);
+        this.pub.send([keyToTopic(ctrl), encoded]);
     }
 }