ros-mobile-bridge 0.1.0 → 0.1.1

package/CHANGELOG.md

@@ -4,6 +4,24 @@ All notable changes to `ros-mobile-bridge` will be documented in this file.
 
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.1.1] - 2026-05-27
+
+### Fixed
+
+- **`FoxgloveClient.callService` against `foxglove_bridge >= 3.2.6` (foxglove-sdk-cpp v0.18.0+) hung until timeout because the bridge rejects JSON-encoded service requests** even when it advertises `supportedEncodings: ["cdr", "json"]` — that capability applies to topic messages, not service calls. Service-call requests are now CDR-encoded using the per-service `requestSchema` shipped by the bridge in `advertiseServices`; the response is decoded with the corresponding `responseSchema`. The fix is backward-compatible with older bridges (CDR is the canonical ROS 2 service encoding and has always been accepted). Verified at the wire level against ROS Jazzy + `foxglove_bridge` 3.2.6.
+- **`FoxgloveClient` now handles the `serviceCallFailure` op** alongside `serviceCallResponse`. Failures from the bridge (unknown service, malformed request, schema mismatch, unsupported encoding) reject the in-flight call promise immediately with the bridge's message instead of being silently dropped until the 30 s timeout.
+- **`FoxgloveClient.callService` against schemaless service advertisements now works for empty requests.** `foxglove_bridge` 3.2.6+ commonly advertises services with their type name but without inline request-schema text — the normal shape for services discovered via ROS 2 graph introspection rather than explicit `.srv` files. The client now detects this case: if the caller's request is empty (`{}`, `null`, or `undefined`), it sends only the 4-byte CDR encapsulation header and the bridge default-constructs the request server-side from the known type. Non-empty requests against schemaless services still surface a clear error explaining the limitation (the encoder genuinely cannot serialize without field-layout information).
+- **`FoxgloveClient.callService` now resolves request and response schemas through a layered fallback.** Order of resolution: (1) the bridge-advertised `requestSchema` / `responseSchema` (authoritative when present), (2) a bundled IDL for six well-known ROS 2 system services — `rcl_interfaces/srv/{ListParameters,GetParameters,SetParameters,DescribeParameters,GetParameterTypes}` and `action_msgs/srv/CancelGoal` — which `foxglove_bridge` 3.2.6+ commonly discovers via introspection without shipping schemas inline, (3) the 4-byte encapsulation-header fallback for empty requests when neither source has a schema. Parameter operations and action cancellation now work against any compliant bridge configuration, not only ones that ship `.srv`-derived schemas. When defs are available, an empty caller request `{}` is now filled with zero values via `schemaToTemplate` rather than rejected on missing fields, making `{}` a stable "default request" sentinel across sim and real-bridge setups.
+- **`FoxgloveClient` now dispatches inbound binary opcode `0x03` SERVICE_CALL_RESPONSE frames.** Previous revisions consumed only the JSON-op response shape; `foxglove-sdk-cpp` 0.18.0+ defaults to the binary 0x03 frame for every service-call response, so pending callIds never resolved and surfaced as 30-second timeouts. The binary path and the legacy JSON-op path now route through a shared decoder; both CDR and JSON response payloads are handled.
+- **`FoxgloveClient` now sends SERVICE_CALL_REQUEST as the spec-defined binary opcode `0x02` frame** instead of the JSON op of the same name. The JSON form is not in the Foxglove WS v1 spec and is rejected by current bridges with a level-2 status message, leaving callIds hanging until the 30-second timeout.
+- **`FoxgloveClient` no longer emits the JSON `ping` keep-alive every 5 seconds.** The op is not in the Foxglove WS v1 spec; modern bridges emit a level-2 status in response to each one. WebSocket-level RFC 6455 ping/pong handles connection liveness at the transport layer and does not need application-level emulation. Existing `pong` responses from older bridges are ignored without error.
+- **`FoxgloveClient` now fast-fails in-flight service calls when the bridge sends a level-2 status message naming `serviceCallRequest`.** These undirected status messages do not carry a callId, so prior versions had no way to associate them with the failing call and all in-flight callIds hung until their 30-second timeout. The substring match keeps the rejection scoped to service-call surfaces; unrelated level-2 messages do not tear down healthy calls.
+- **`FoxgloveClient` outbound binary frames are now sent as `Uint8Array`, not raw `ArrayBuffer`.** React Native's WebSocket native bridge silently drops `send(ArrayBuffer)` payloads above roughly 400 bytes; this manifested as 16-name `get_parameters` requests never leaving the device (confirmed via tcpdump). Sending via `Uint8Array` uses a different RN native serializer that handles every payload size we send. Same bytes on the wire for browsers and Node; this is load-bearing for React Native consumers and is covered by a regression test.
+
+### Changed
+
+- **`ProtocolClientOptions.onLatency` is no longer driven by `FoxgloveClient`** as a consequence of removing the JSON `ping`/`pong` keep-alive (see Fixed). The option remains in the public type and is still driven by `RosbridgeClient` via its dedicated latency-probe path. Foxglove WS RTT measurement will return when a portable spec-compliant signal is available; browsers do not expose `ws.ping()` from JavaScript.
+
 ## [0.1.0] - 2026-05-20
 
 ### Added
@@ -25,4 +43,5 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 
 - `ZenohClient` ships as an unimplemented skeleton (every method throws). `ProtocolManager.connect` throws a clear "Zenoh support is planned for v0.2.0" error for `protocol: 'zenoh'`. The class is not exported from `index.ts` in v0.1.0.
 
+[0.1.1]: https://github.com/AuriLabsTech/ros-mobile-bridge/releases/tag/v0.1.1
 [0.1.0]: https://github.com/AuriLabsTech/ros-mobile-bridge/releases/tag/v0.1.0

package/ROADMAP.md

@@ -30,7 +30,12 @@ The `ZenohClient` skeleton already exists in `src/ZenohClient.ts` as roadmap-as-
 - Integration tests against a real `rmw_zenoh` setup (`zenohd` + `zenoh-plugin-remote-api` + a ROS 2 node) in CI.
 - Documentation: a dedicated section in the README describing when Zenoh is the right transport choice versus the existing two, and a runnable example under `examples/zenoh/`.
 
-**Why this matters:** Zenoh is the recommended middleware for the next generation of ROS 2 deployments (it underlies `rmw_zenoh`, which the OSRF has positioned as a serious alternative to the default DDS-based middleware). No existing JavaScript or TypeScript library provides a ROS 2 client over Zenoh that works in mobile and web runtimes. `v0.2.0` closes that gap.
+**Open questions resolved first (a spike opens this milestone):**
+
+- **React Native support is unverified.** `@eclipse-zenoh/zenoh-ts` ships a WebAssembly module for key-expression handling. WASM runs cleanly in browsers, Node, and Electron, but React Native (Hermes) WASM support is limited. If the dependency does not run under React Native, the Zenoh transport may initially target browser / Node / Electron with React Native to follow.
+- **Schema acquisition differs from Foxglove WS.** `rmw_zenoh` does not distribute message definitions inline, so CDR decoding needs definitions sourced another way (bundled common interfaces, consumer-provided, or a registry). The spike scopes this.
+
+**Why this matters:** Zenoh is the recommended middleware for the next generation of ROS 2 deployments (it underlies `rmw_zenoh`, which the OSRF has positioned as a serious alternative to the default DDS-based middleware). No existing JavaScript or TypeScript library provides a ROS 2 client over Zenoh for these runtimes; `v0.2.0` aims to close that gap, with mobile-runtime support contingent on the verification above.
 
 ## v0.3.0 — Hardening and community
 

package/dist/index.cjs

@@ -478,6 +478,112 @@ function jsonSchemaToTemplate(schema) {
   return null;
 }
 
+// src/builtinSchemas.ts
+var SEP = "\n================================================================================\n";
+var MSG_PARAMETER_VALUE = `MSG: rcl_interfaces/ParameterValue
+uint8 type
+bool bool_value
+int64 integer_value
+float64 double_value
+string string_value
+byte[] byte_array_value
+bool[] bool_array_value
+int64[] integer_array_value
+float64[] double_array_value
+string[] string_array_value`;
+var MSG_PARAMETER = `MSG: rcl_interfaces/Parameter
+string name
+ParameterValue value`;
+var MSG_SET_PARAMETERS_RESULT = `MSG: rcl_interfaces/SetParametersResult
+bool successful
+string reason`;
+var MSG_LIST_PARAMETERS_RESULT = `MSG: rcl_interfaces/ListParametersResult
+string[] names
+string[] prefixes`;
+var MSG_FLOATING_POINT_RANGE = `MSG: rcl_interfaces/FloatingPointRange
+float64 from_value
+float64 to_value
+float64 step`;
+var MSG_INTEGER_RANGE = `MSG: rcl_interfaces/IntegerRange
+int64 from_value
+int64 to_value
+uint64 step`;
+var MSG_PARAMETER_DESCRIPTOR = `MSG: rcl_interfaces/ParameterDescriptor
+string name
+uint8 type
+string description
+string additional_constraints
+bool read_only
+bool dynamic_typing
+FloatingPointRange[] floating_point_range
+IntegerRange[] integer_range`;
+var MSG_TIME = `MSG: builtin_interfaces/Time
+int32 sec
+uint32 nanosec`;
+var MSG_UUID = `MSG: unique_identifier_msgs/UUID
+uint8[16] uuid`;
+var MSG_GOAL_INFO = `MSG: action_msgs/GoalInfo
+unique_identifier_msgs/UUID goal_id
+builtin_interfaces/Time stamp`;
+var LIST_PARAMETERS_REQUEST = `uint64 DEPTH_RECURSIVE=0
+string[] prefixes
+uint64 depth`;
+var LIST_PARAMETERS_RESPONSE = ["ListParametersResult result", MSG_LIST_PARAMETERS_RESULT].join(SEP);
+var GET_PARAMETERS_REQUEST = "string[] names";
+var GET_PARAMETERS_RESPONSE = ["ParameterValue[] values", MSG_PARAMETER_VALUE].join(SEP);
+var SET_PARAMETERS_REQUEST = ["Parameter[] parameters", MSG_PARAMETER, MSG_PARAMETER_VALUE].join(SEP);
+var SET_PARAMETERS_RESPONSE = ["SetParametersResult[] results", MSG_SET_PARAMETERS_RESULT].join(SEP);
+var DESCRIBE_PARAMETERS_REQUEST = "string[] names";
+var DESCRIBE_PARAMETERS_RESPONSE = [
+  "ParameterDescriptor[] descriptors",
+  MSG_PARAMETER_DESCRIPTOR,
+  MSG_FLOATING_POINT_RANGE,
+  MSG_INTEGER_RANGE
+].join(SEP);
+var GET_PARAMETER_TYPES_REQUEST = "string[] names";
+var GET_PARAMETER_TYPES_RESPONSE = "uint8[] types";
+var CANCEL_GOAL_REQUEST = ["GoalInfo goal_info", MSG_GOAL_INFO, MSG_UUID, MSG_TIME].join(SEP);
+var CANCEL_GOAL_RESPONSE = [
+  `int8 ERROR_NONE = 0
+int8 ERROR_REJECTED = 1
+int8 ERROR_UNKNOWN_GOAL_ID = 2
+int8 ERROR_GOAL_TERMINATED = 3
+int8 return_code
+GoalInfo[] goals_canceling`,
+  MSG_GOAL_INFO,
+  MSG_UUID,
+  MSG_TIME
+].join(SEP);
+var BUNDLED = {
+  "rcl_interfaces/srv/ListParameters": {
+    request: LIST_PARAMETERS_REQUEST,
+    response: LIST_PARAMETERS_RESPONSE
+  },
+  "rcl_interfaces/srv/GetParameters": {
+    request: GET_PARAMETERS_REQUEST,
+    response: GET_PARAMETERS_RESPONSE
+  },
+  "rcl_interfaces/srv/SetParameters": {
+    request: SET_PARAMETERS_REQUEST,
+    response: SET_PARAMETERS_RESPONSE
+  },
+  "rcl_interfaces/srv/DescribeParameters": {
+    request: DESCRIBE_PARAMETERS_REQUEST,
+    response: DESCRIBE_PARAMETERS_RESPONSE
+  },
+  "rcl_interfaces/srv/GetParameterTypes": {
+    request: GET_PARAMETER_TYPES_REQUEST,
+    response: GET_PARAMETER_TYPES_RESPONSE
+  },
+  "action_msgs/srv/CancelGoal": {
+    request: CANCEL_GOAL_REQUEST,
+    response: CANCEL_GOAL_RESPONSE
+  }
+};
+function getBundledServiceSchema(serviceType) {
+  return BUNDLED[serviceType] ?? null;
+}
+
 // src/FoxgloveClient.ts
 var NOOP_LOGGER = { log() {
 }, warn() {
@@ -485,9 +591,46 @@ var NOOP_LOGGER = { log() {
 } };
 var TEXT_ENCODER = new TextEncoder();
 var TEXT_DECODER = new TextDecoder();
+function base64ToUint8(b64) {
+  const binary = atob(b64);
+  const out = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) {
+    out[i] = binary.charCodeAt(i);
+  }
+  return out;
+}
+var CDR_LE_HEADER = new Uint8Array([0, 1, 0, 0]);
+function isEmptyRequest(request) {
+  if (request === null || request === void 0) return true;
+  if (typeof request !== "object" || Array.isArray(request)) return false;
+  return Object.keys(request).length === 0;
+}
+function parseFoxgloveSchema(schemaStr, encodingHint) {
+  const declared = (encodingHint ?? "").toLowerCase();
+  const tryRos2idl = () => {
+    try {
+      return ros2idlParser.parseRos2idl(schemaStr);
+    } catch {
+      return null;
+    }
+  };
+  const tryRos2msg = () => {
+    try {
+      return rosmsg.parse(schemaStr, { ros2: true });
+    } catch {
+      return null;
+    }
+  };
+  const order = declared === "ros2idl" ? [tryRos2idl, tryRos2msg] : [tryRos2msg, tryRos2idl];
+  for (const attempt of order) {
+    const defs = attempt();
+    if (defs && defs.length > 0) return defs;
+  }
+  throw new Error(
+    `Could not parse schema (encodingHint=${encodingHint ?? "none"}, preview="${schemaStr.substring(0, 80)}")`
+  );
+}
 var SUBPROTOCOLS = ["foxglove.sdk.v1", "foxglove.websocket.v1"];
-var PING_INTERVAL_MS = 5e3;
-var PONG_TIMEOUT_MS = 1e4;
 var MAX_RECONNECT_ATTEMPTS = 5;
 var BASE_RECONNECT_DELAY_MS = 1e3;
 var CONNECTION_TIMEOUT_MS = 1e4;
@@ -498,7 +641,6 @@ var ZERO_TWIST = {
 var CMD_VEL_SCHEMA = "geometry_msgs/msg/Twist";
 var _FoxgloveClient = class _FoxgloveClient {
   constructor(options) {
-    __publicField(this, "onLatency");
     __publicField(this, "logger");
     __publicField(this, "getThrottleMode");
     __publicField(this, "presets");
@@ -532,10 +674,21 @@ var _FoxgloveClient = class _FoxgloveClient {
     __publicField(this, "nextServiceCallId", 1);
     __publicField(this, "pendingServiceCalls", /* @__PURE__ */ new Map());
     __publicField(this, "availableServices", /* @__PURE__ */ new Map());
-    // Keep-alive
-    __publicField(this, "pingTimer", null);
-    __publicField(this, "pongTimer", null);
-    __publicField(this, "lastPingSentTime", 0);
+    /**
+     * Per-service CDR codecs. Compiled lazily on first call from the schema
+     * the bridge shipped in `advertiseServices`. Foxglove WS service requests
+     * and responses are CDR-encoded for ROS 2; the codec parses the bare
+     * Request/Response struct (the bridge handles `rmw_request_id_t` wrapping).
+     */
+    // The defs caches hold the parsed MessageDefinition[] keyed by service id.
+    // Keeping them alongside the writer/reader caches buys two things: cheap
+    // lookup of zero-value defaults (via schemaToTemplate) when the caller
+    // passes an empty request, and a single source of truth for "where did
+    // this schema come from" (bridge-advertised, bundled fallback, or neither).
+    __publicField(this, "serviceRequestDefs", /* @__PURE__ */ new Map());
+    __publicField(this, "serviceResponseDefs", /* @__PURE__ */ new Map());
+    __publicField(this, "serviceRequestWriters", /* @__PURE__ */ new Map());
+    __publicField(this, "serviceResponseReaders", /* @__PURE__ */ new Map());
     // Reconnection
     __publicField(this, "reconnectAttempts", 0);
     __publicField(this, "reconnectTimer", null);
@@ -545,7 +698,6 @@ var _FoxgloveClient = class _FoxgloveClient {
     __publicField(this, "connectResolve", null);
     __publicField(this, "connectReject", null);
     __publicField(this, "serverInfoReceived", false);
-    this.onLatency = options?.onLatency;
     this.logger = options?.logger ?? NOOP_LOGGER;
     this.getThrottleMode = options?.getThrottleMode ?? (() => "auto");
     this.presets = buildEffectivePresets(options?.presetOverrides, this.logger);
@@ -842,7 +994,33 @@ var _FoxgloveClient = class _FoxgloveClient {
     view.setUint8(0, 1 /* MESSAGE_DATA */);
     view.setUint32(1, channelId, true);
     new Uint8Array(buffer, 5).set(payloadBytes);
-    this.ws.send(buffer);
+    this.ws.send(new Uint8Array(buffer));
+  }
+  /**
+   * Send a service-call request as a binary opcode-0x02 frame. Per
+   * Foxglove WS v1 spec, SERVICE_CALL_REQUEST is binary only; the JSON op
+   * `serviceCallRequest` that earlier revisions used is not in the spec
+   * and is rejected by current bridges with a `status` level-2 message,
+   * which leaves the in-flight callId hanging until the 30 s timeout.
+   *
+   * Frame layout mirrors the inbound 0x03 SERVICE_CALL_RESPONSE parser:
+   *   [uint8 op=0x02][uint32 serviceId LE][uint32 callId LE]
+   *   [uint32 encLen LE][utf8 encoding][bytes payload]
+   */
+  sendBinaryServiceCallRequest(serviceId, callId, encoding, payload) {
+    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) return;
+    const encodingBytes = TEXT_ENCODER.encode(encoding);
+    const buffer = new ArrayBuffer(
+      1 + 4 + 4 + 4 + encodingBytes.byteLength + payload.byteLength
+    );
+    const view = new DataView(buffer);
+    view.setUint8(0, 2 /* SERVICE_CALL_REQUEST */);
+    view.setUint32(1, serviceId, true);
+    view.setUint32(5, callId, true);
+    view.setUint32(9, encodingBytes.byteLength, true);
+    new Uint8Array(buffer, 13, encodingBytes.byteLength).set(encodingBytes);
+    new Uint8Array(buffer, 13 + encodingBytes.byteLength).set(payload);
+    this.ws.send(new Uint8Array(buffer));
   }
   async callService(service, request) {
     if (!this.ws || this.status !== "connected") {
@@ -859,17 +1037,98 @@ var _FoxgloveClient = class _FoxgloveClient {
         reject(new Error(`Service call "${service}" timed out after 30s`));
       }, 3e4);
       this.pendingServiceCalls.set(callId, { resolve, reject, timer });
-      const jsonData = JSON.stringify(request);
-      const encoded = btoa(jsonData);
-      this.sendJson({
-        op: "serviceCallRequest",
-        serviceId: serviceInfo.id,
-        callId,
-        encoding: "json",
-        data: encoded
-      });
+      let payloadBytes;
+      try {
+        const reqDefs = this.getRequestDefs(serviceInfo);
+        if (reqDefs) {
+          const writer = this.getOrCompileRequestWriter(serviceInfo.id, reqDefs);
+          const payload = isEmptyRequest(request) ? schemaToTemplate(reqDefs) : request;
+          payloadBytes = writer.writeMessage(payload);
+        } else if (isEmptyRequest(request)) {
+          payloadBytes = CDR_LE_HEADER;
+        } else {
+          throw new Error(
+            `Service "${service}" (type "${serviceInfo.type}") has no request schema advertised and is not in the built-in fallback bundle; cannot encode a non-empty CDR request. The bridge omits inline schemas for services discovered via introspection; empty requests still work via the encapsulation-header fallback.`
+          );
+        }
+      } catch (err) {
+        clearTimeout(timer);
+        this.pendingServiceCalls.delete(callId);
+        reject(
+          new Error(
+            `Failed to encode request for "${service}": ${err instanceof Error ? err.message : String(err)}`
+          )
+        );
+        return;
+      }
+      this.sendBinaryServiceCallRequest(serviceInfo.id, callId, "cdr", payloadBytes);
     });
   }
+  /**
+   * Resolve the parsed request-side {@link MessageDefinition}[] for a
+   * service, preferring the bridge-advertised schema and falling back to
+   * the built-in bundle (`src/builtinSchemas.ts`) when the bridge omitted
+   * one. Returns `null` if neither source has anything for this service —
+   * callers then choose between the encapsulation-header fallback (for
+   * empty requests) and an explicit error (for non-empty ones). Cached
+   * per service id; parse + bundle lookup runs at most once per service
+   * advertisement.
+   */
+  getRequestDefs(svc) {
+    const cached = this.serviceRequestDefs.get(svc.id);
+    if (cached) return cached;
+    if (svc.requestSchema) {
+      const defs = parseFoxgloveSchema(svc.requestSchema, svc.requestSchemaEncoding);
+      this.serviceRequestDefs.set(svc.id, defs);
+      return defs;
+    }
+    const bundled = getBundledServiceSchema(svc.type);
+    if (bundled) {
+      const defs = rosmsg.parse(bundled.request, { ros2: true });
+      this.serviceRequestDefs.set(svc.id, defs);
+      return defs;
+    }
+    return null;
+  }
+  /** Response-side counterpart to {@link getRequestDefs}; same precedence. */
+  getResponseDefs(svc) {
+    const cached = this.serviceResponseDefs.get(svc.id);
+    if (cached) return cached;
+    if (svc.responseSchema) {
+      const defs = parseFoxgloveSchema(svc.responseSchema, svc.responseSchemaEncoding);
+      this.serviceResponseDefs.set(svc.id, defs);
+      return defs;
+    }
+    const bundled = getBundledServiceSchema(svc.type);
+    if (bundled) {
+      const defs = rosmsg.parse(bundled.response, { ros2: true });
+      this.serviceResponseDefs.set(svc.id, defs);
+      return defs;
+    }
+    return null;
+  }
+  /** Lazily compile and cache the CDR writer for a service's request type. */
+  getOrCompileRequestWriter(serviceId, defs) {
+    const cached = this.serviceRequestWriters.get(serviceId);
+    if (cached) return cached;
+    const writer = new rosmsg2Serialization.MessageWriter(defs);
+    this.serviceRequestWriters.set(serviceId, writer);
+    return writer;
+  }
+  /** Lazily compile and cache the CDR reader for a service's response type. */
+  getOrCompileResponseReader(serviceId, defs) {
+    const cached = this.serviceResponseReaders.get(serviceId);
+    if (cached) return cached;
+    const reader = new rosmsg2Serialization.MessageReader(defs);
+    this.serviceResponseReaders.set(serviceId, reader);
+    return reader;
+  }
+  findServiceById(serviceId) {
+    for (const svc of this.availableServices.values()) {
+      if (svc.id === serviceId) return svc;
+    }
+    return void 0;
+  }
   onStatusChange(cb) {
     this.statusListeners.add(cb);
     cb(this.status);
@@ -980,26 +1239,41 @@ var _FoxgloveClient = class _FoxgloveClient {
       case "serviceCallResponse":
         this.handleServiceCallResponse(msg);
         break;
-      case "pong":
-        this.handlePong();
+      case "serviceCallFailure":
+        this.handleServiceCallFailure(msg);
         break;
       case "schemas":
         break;
-      case "status":
-        if (msg.level === 2) {
-          this.logger.error(
-            "[FoxgloveClient] Server error:",
-            msg.message
-          );
+      case "status": {
+        const status = msg;
+        if (status.level === 2) {
+          const text = status.message ?? "";
+          this.logger.error("[FoxgloveClient] Server error:", text);
+          if (/serviceCallRequest/i.test(text) && this.pendingServiceCalls.size > 0) {
+            this.rejectAllPendingServiceCalls(`Bridge rejected service call: ${text}`);
+          }
         }
         break;
+      }
     }
   }
   handleBinaryMessage(buffer) {
-    if (buffer.byteLength < 5) return;
+    if (buffer.byteLength < 1) return;
     const view = new DataView(buffer);
     const opcode = view.getUint8(0);
-    if (opcode !== 1 /* MESSAGE_DATA */) return;
+    switch (opcode) {
+      case 1 /* MESSAGE_DATA */:
+        this.handleBinaryMessageData(buffer, view);
+        return;
+      case 3 /* SERVICE_CALL_RESPONSE */:
+        this.handleBinaryServiceCallResponse(buffer, view);
+        return;
+      default:
+        return;
+    }
+  }
+  handleBinaryMessageData(buffer, view) {
+    if (buffer.byteLength < 13) return;
     const subscriptionId = view.getUint32(1, true);
     const timestampLow = view.getUint32(5, true);
     const timestampHigh = view.getUint32(9, true);
@@ -1084,7 +1358,6 @@ var _FoxgloveClient = class _FoxgloveClient {
       this.clearConnectionTimeout();
       this.reconnectAttempts = 0;
       this.setStatus("connected");
-      this.startPingLoop();
       this.connectResolve();
       this.connectResolve = null;
       this.connectReject = null;
@@ -1118,15 +1391,51 @@ var _FoxgloveClient = class _FoxgloveClient {
       }
     }
   }
+  /**
+   * Service-call responses arrive on two distinct wire paths and both
+   * funnel into {@link dispatchServiceCallResponse}:
+   *
+   *   1. JSON op `serviceCallResponse` (handled here) — older bridges
+   *      and any deployment with binary responses disabled. `data` is
+   *      base64, decoded once into a Uint8Array before dispatch.
+   *   2. Binary opcode 0x03 (handled in
+   *      {@link handleBinaryServiceCallResponse}) — the default for
+   *      foxglove-sdk-cpp ≥ 0.18.0 / foxglove_bridge 3.2.6+. Payload
+   *      bytes are passed through directly with no base64 round-trip.
+   *
+   * Before this split, only the JSON path existed and the binary
+   * frames were dropped by {@link handleBinaryMessage} — pending callIds
+   * never resolved and surfaced as 30 s timeouts on every callService.
+   */
   handleServiceCallResponse(msg) {
-    const pending = this.pendingServiceCalls.get(msg.callId);
+    const payload = msg.data ? base64ToUint8(msg.data) : new Uint8Array();
+    this.dispatchServiceCallResponse(msg.callId, msg.serviceId, msg.encoding ?? "", payload);
+  }
+  /**
+   * Inner decode + dispatch shared by the JSON-op and binary-frame
+   * paths. Owns the lookup of the pending call, the timer cleanup, and
+   * the CDR / JSON branch — splitting it out keeps the two surface
+   * paths thin and prevents drift between them.
+   */
+  dispatchServiceCallResponse(callId, serviceId, encoding, payload) {
+    const pending = this.pendingServiceCalls.get(callId);
     if (!pending) return;
     clearTimeout(pending.timer);
-    this.pendingServiceCalls.delete(msg.callId);
+    this.pendingServiceCalls.delete(callId);
     try {
-      if (msg.encoding === "json" && msg.data) {
-        const decoded = atob(msg.data);
-        const parsed = JSON.parse(decoded);
+      if (encoding === "cdr" && payload.byteLength > 0) {
+        const svc = this.findServiceById(serviceId);
+        const respDefs = svc ? this.getResponseDefs(svc) : null;
+        if (!svc || !respDefs) {
+          pending.resolve({ rawBytes: payload });
+          return;
+        }
+        const reader = this.getOrCompileResponseReader(svc.id, respDefs);
+        const decoded = reader.readMessage(payload);
+        pending.resolve(decoded);
+      } else if (encoding === "json" && payload.byteLength > 0) {
+        const text = TEXT_DECODER.decode(payload);
+        const parsed = JSON.parse(text);
         pending.resolve(parsed);
       } else {
         pending.resolve({ success: true });
@@ -1139,45 +1448,54 @@ var _FoxgloveClient = class _FoxgloveClient {
       );
     }
   }
-  // ── Private: keep-alive ──────────────────────────────────────────────────
-  startPingLoop() {
-    this.stopPingLoop();
-    this.pingTimer = setInterval(() => {
-      if (this.ws && this.ws.readyState === WebSocket.OPEN) {
-        if (this.pongTimer) {
-          clearTimeout(this.pongTimer);
-          this.pongTimer = null;
-        }
-        this.lastPingSentTime = Date.now();
-        this.sendJson({ op: "ping" });
-        this.pongTimer = setTimeout(() => {
-          this.logger.warn("[FoxgloveClient] Pong timeout \u2014 reconnecting");
-          this.handleClose(4e3, "Pong timeout");
-        }, PONG_TIMEOUT_MS);
-      }
-    }, PING_INTERVAL_MS);
+  /**
+   * Parse a binary opcode-0x03 SERVICE_CALL_RESPONSE frame and dispatch
+   * to {@link dispatchServiceCallResponse}. Frame layout (LE throughout):
+   *
+   *   [uint8 op=0x03][uint32 serviceId][uint32 callId]
+   *   [uint32 encodingLength][utf8 encoding][bytes payload]
+   *
+   * Malformed frames (too short for the header, or an `encodingLength`
+   * that runs past the buffer) are dropped silently — the bridge will
+   * either resend or fail the call via the JSON `serviceCallFailure`
+   * op, and either way logging on the hot binary path would be noisy.
+   */
+  handleBinaryServiceCallResponse(buffer, view) {
+    if (buffer.byteLength < 13) return;
+    const serviceId = view.getUint32(1, true);
+    const callId = view.getUint32(5, true);
+    const encodingLength = view.getUint32(9, true);
+    const payloadOffset = 13 + encodingLength;
+    if (buffer.byteLength < payloadOffset) return;
+    const encoding = TEXT_DECODER.decode(new Uint8Array(buffer, 13, encodingLength));
+    const payload = new Uint8Array(buffer, payloadOffset);
+    this.dispatchServiceCallResponse(callId, serviceId, encoding, payload);
   }
-  stopPingLoop() {
-    if (this.pingTimer) {
-      clearInterval(this.pingTimer);
-      this.pingTimer = null;
-    }
-    if (this.pongTimer) {
-      clearTimeout(this.pongTimer);
-      this.pongTimer = null;
-    }
+  /**
+   * Handle a `serviceCallFailure` op (callId-targeted rejection from the
+   * bridge). Without this, failures sat unhandled and the in-flight promise
+   * timed out at 30 s — turning every misencoded request, unknown service,
+   * or schema mismatch into a long, opaque hang.
+   */
+  handleServiceCallFailure(msg) {
+    const pending = this.pendingServiceCalls.get(msg.callId);
+    if (!pending) return;
+    clearTimeout(pending.timer);
+    this.pendingServiceCalls.delete(msg.callId);
+    pending.reject(new Error(msg.message ?? "Service call failed (no message from bridge)"));
   }
-  handlePong() {
-    if (this.pongTimer) {
-      clearTimeout(this.pongTimer);
-      this.pongTimer = null;
-    }
-    if (this.onLatency && this.lastPingSentTime > 0) {
-      try {
-        this.onLatency(Date.now() - this.lastPingSentTime);
-      } catch {
-      }
+  /**
+   * Reject every in-flight service call with `reason`, clear their timers,
+   * and empty the pending map. Used by {@link cleanup} on disconnect and
+   * by the status-level-2 fast-fail path where the bridge has signalled a
+   * service-call rejection without naming a callId.
+   */
+  rejectAllPendingServiceCalls(reason) {
+    for (const pending of this.pendingServiceCalls.values()) {
+      clearTimeout(pending.timer);
+      pending.reject(new Error(reason));
     }
+    this.pendingServiceCalls.clear();
   }
   // ── Private: reconnection ────────────────────────────────────────────────
   handleConnectionError(error) {
@@ -1304,16 +1622,11 @@ var _FoxgloveClient = class _FoxgloveClient {
   // ── Private: cleanup ─────────────────────────────────────────────────────
   cleanup() {
     this.clearConnectionTimeout();
-    this.stopPingLoop();
     if (this.reconnectTimer) {
       clearTimeout(this.reconnectTimer);
       this.reconnectTimer = null;
     }
-    for (const [, pending] of this.pendingServiceCalls) {
-      clearTimeout(pending.timer);
-      pending.reject(new Error("Connection closed"));
-    }
-    this.pendingServiceCalls.clear();
+    this.rejectAllPendingServiceCalls("Connection closed");
     if (this.ws) {
       if (this.ws.readyState === WebSocket.OPEN && this.advertisedTopics.size > 0) {
         const channelIds = Array.from(this.advertisedTopics.values());
@@ -1338,6 +1651,10 @@ var _FoxgloveClient = class _FoxgloveClient {
     this.messageReaders.clear();
     this.advertisedTopics.clear();
     this.availableServices.clear();
+    this.serviceRequestDefs.clear();
+    this.serviceResponseDefs.clear();
+    this.serviceRequestWriters.clear();
+    this.serviceResponseReaders.clear();
     this.notifyServicesChanged();
     this.serverInfoReceived = false;
     this.nextSubscriptionId = 1;