ros-mobile-bridge 0.1.0

package/dist/index.cjs

@@ -0,0 +1,2288 @@
+'use strict';
+
+var rosmsg = require('@foxglove/rosmsg');
+var ros2idlParser = require('@foxglove/ros2idl-parser');
+var rosmsg2Serialization = require('@foxglove/rosmsg2-serialization');
+
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+// src/CircuitBreaker.ts
+var HEALTHY_DEBOUNCE_MS = 4e3;
+var WARMUP_MS = 2e3;
+var CircuitBreaker = class {
+  constructor(config) {
+    __publicField(this, "config", config);
+    __publicField(this, "state", "closed");
+    __publicField(this, "tripCount", 0);
+    __publicField(this, "saturationObservedAt", 0);
+    __publicField(this, "healthyObservedAt", 0);
+    __publicField(this, "cooldownTimer", null);
+    __publicField(this, "subscriptionStartedAt", Date.now());
+    __publicField(this, "nextRetryAt", null);
+  }
+  getState() {
+    return this.state;
+  }
+  /**
+   * `Date.now()` when auto-retry is scheduled to fire, or `null` if no
+   * cooldown is running (closed / half_open / tripped_manual).
+   */
+  getNextRetryAt() {
+    return this.nextRetryAt;
+  }
+  /**
+   * Single entry point for "I saw a message; here's the current bandwidth
+   * and JS-thread lag." Internally gates by `HEAVY_BANDWIDTH_THRESHOLD_BYTES_PER_SEC`
+   * and the breaker's `lagThresholdMs` so the trip policy lives in one place
+   * instead of being replicated at every call site.
+   */
+  recordObservation(now, bytesPerSec, lagMs) {
+    if (bytesPerSec > HEAVY_BANDWIDTH_THRESHOLD_BYTES_PER_SEC && lagMs > this.config.lagThresholdMs) {
+      this.recordOverloaded(now);
+    } else {
+      this.recordHealthy(now);
+    }
+  }
+  /**
+   * Called from the protocol client's `recordBytes` when the tracker is in
+   * the heavily-throttled range (top buckets) and lag exceeds the threshold.
+   */
+  recordOverloaded(now) {
+    if (now - this.subscriptionStartedAt < WARMUP_MS) return;
+    if (this.state === "closed" || this.state === "half_open") {
+      if (this.saturationObservedAt === 0) {
+        this.saturationObservedAt = now;
+      } else if (now - this.saturationObservedAt >= this.config.tripDwellMs) {
+        this.trip();
+      }
+      this.healthyObservedAt = 0;
+    }
+  }
+  /**
+   * Called from `recordBytes` when lag is below threshold or the tracker is
+   * below the heavily-throttled range.
+   */
+  recordHealthy(now) {
+    if (now - this.subscriptionStartedAt < WARMUP_MS) return;
+    if (this.state !== "closed" && this.state !== "half_open") return;
+    if (this.healthyObservedAt === 0) {
+      this.healthyObservedAt = now;
+    }
+    const healthyDwell = now - this.healthyObservedAt;
+    if (this.saturationObservedAt > 0 && healthyDwell >= HEALTHY_DEBOUNCE_MS) {
+      this.saturationObservedAt = 0;
+    }
+    if (this.state === "half_open" && healthyDwell >= this.config.recoveryDwellMs) {
+      this.close();
+    }
+  }
+  /**
+   * User pressed "try again now" — bypasses the cooldown timer and jumps
+   * straight to `half_open`. Works from any tripped state.
+   */
+  retry() {
+    if (this.state === "tripped_auto" || this.state === "tripped_manual") {
+      this.clearCooldown();
+      this.openHalf();
+    }
+  }
+  /**
+   * User pressed "stop trying" — switches `tripped_auto` to `tripped_manual`
+   * and cancels the auto-retry timer. The subscription remains paused until
+   * the user manually retries.
+   */
+  disable() {
+    if (this.state === "tripped_auto") {
+      this.clearCooldown();
+      this.transition("tripped_manual");
+    }
+  }
+  /**
+   * Called by the protocol client on disconnect or unsubscribe so the
+   * cooldown timer doesn't outlive the connection.
+   */
+  destroy() {
+    this.clearCooldown();
+  }
+  // ── Internal transitions ─────────────────────────────────────────────
+  trip() {
+    this.tripCount++;
+    this.saturationObservedAt = 0;
+    const cooldownIdx = Math.min(this.tripCount - 1, this.config.cooldownsMs.length - 1);
+    const cooldownMs = this.config.cooldownsMs[cooldownIdx] ?? 3e4;
+    this.nextRetryAt = Date.now() + cooldownMs;
+    this.transition("tripped_auto");
+    this.cooldownTimer = setTimeout(() => {
+      this.cooldownTimer = null;
+      this.nextRetryAt = null;
+      if (this.state === "tripped_auto") {
+        this.openHalf();
+      }
+    }, cooldownMs);
+  }
+  openHalf() {
+    const now = Date.now();
+    this.saturationObservedAt = 0;
+    this.healthyObservedAt = 0;
+    this.subscriptionStartedAt = now;
+    this.transition("half_open");
+  }
+  close() {
+    this.saturationObservedAt = 0;
+    this.transition("closed");
+  }
+  transition(next) {
+    const prev = this.state;
+    if (prev === next) return;
+    this.state = next;
+    try {
+      this.config.onStateChange(next, prev);
+    } catch {
+    }
+  }
+  clearCooldown() {
+    if (this.cooldownTimer !== null) {
+      clearTimeout(this.cooldownTimer);
+      this.cooldownTimer = null;
+    }
+    this.nextRetryAt = null;
+  }
+};
+var DEFAULT_BREAKER_CONFIG = {
+  lagThresholdMs: 250,
+  tripDwellMs: 5e3,
+  recoveryDwellMs: 1e4,
+  cooldownsMs: [3e4, 6e4, 12e4, 3e5]
+};
+var HEAVY_BANDWIDTH_THRESHOLD_BYTES_PER_SEC = 5e5;
+
+// src/EventLoopMonitor.ts
+var PROBE_INTERVAL_MS = 200;
+var WINDOW_MS = 1e3;
+var HISTORY_MAX = 600;
+var started = false;
+var lastTickAt = 0;
+var samples = [];
+var history = [];
+var modeGetter = () => "auto";
+function setModeGetter(fn) {
+  modeGetter = fn;
+}
+function startMonitor() {
+  if (started) return;
+  started = true;
+  lastTickAt = Date.now();
+  const handle = setInterval(() => {
+    const now = Date.now();
+    const elapsed = now - lastTickAt;
+    const lag = Math.max(0, elapsed - PROBE_INTERVAL_MS);
+    lastTickAt = now;
+    samples.push({ t: now, lag });
+    const cutoff = now - WINDOW_MS;
+    while (samples.length > 0) {
+      const head = samples[0];
+      if (!head || head.t >= cutoff) break;
+      samples.shift();
+    }
+    let mode = "auto";
+    try {
+      mode = modeGetter();
+    } catch {
+    }
+    history.push({ t: now, lag, mode });
+    if (history.length > HISTORY_MAX) {
+      history.shift();
+    }
+  }, PROBE_INTERVAL_MS);
+  const unref = handle?.unref;
+  if (typeof unref === "function") {
+    unref.call(handle);
+  }
+}
+function getMaxLagMs() {
+  if (!started) startMonitor();
+  let max = 0;
+  for (const s of samples) {
+    if (s.lag > max) max = s.lag;
+  }
+  return max;
+}
+function getLagStats() {
+  if (history.length === 0) return null;
+  const sorted = history.map((s) => s.lag).sort((a, b) => a - b);
+  const pick = (q) => {
+    const idx = Math.min(sorted.length - 1, Math.floor(sorted.length * q));
+    return sorted[idx] ?? 0;
+  };
+  const first = history[0];
+  const last = history[history.length - 1];
+  const span = first && last ? (last.t - first.t) / 1e3 : 0;
+  return {
+    count: history.length,
+    durationSec: Math.round(span),
+    p50: pick(0.5),
+    p90: pick(0.9),
+    p99: pick(0.99),
+    max: sorted[sorted.length - 1] ?? 0
+  };
+}
+function getLagHistoryCsv() {
+  const header = "timestamp_ms,lag_ms,mode";
+  const rows = history.map((s) => `${s.t},${s.lag},${s.mode}`);
+  return [header, ...rows].join("\n");
+}
+function clearLagHistory() {
+  history.length = 0;
+}
+
+// src/SubscriptionBandwidth.ts
+var BANDWIDTH_WINDOW_MS = 1e3;
+var TIGHTEN_DWELL_MS = 0;
+var RELAX_DWELL_MS = 3e3;
+var DEFAULT_PRESETS = {
+  performance: [{ threshold: 0, minIntervalMs: 0, label: "none" }],
+  auto: [
+    { threshold: 0, minIntervalMs: 0, label: "none" },
+    { threshold: 100, minIntervalMs: 100, label: "10 Hz" },
+    { threshold: 150, minIntervalMs: 200, label: "5 Hz" },
+    { threshold: 200, minIntervalMs: 1e3, label: "1 Hz" },
+    { threshold: 350, minIntervalMs: 2e3, label: "0.5 Hz" }
+  ],
+  efficient: [
+    { threshold: 0, minIntervalMs: 0, label: "none" },
+    { threshold: 80, minIntervalMs: 100, label: "10 Hz" },
+    { threshold: 130, minIntervalMs: 200, label: "5 Hz" },
+    { threshold: 200, minIntervalMs: 1e3, label: "1 Hz" },
+    { threshold: 350, minIntervalMs: 2e3, label: "0.5 Hz" }
+  ]
+};
+var THROTTLE_MODES = ["performance", "auto", "efficient"];
+var INITIAL_BUCKET_PER_MODE = {
+  performance: 0,
+  auto: 2,
+  efficient: 3
+};
+function validatePreset(buckets, mode, logger) {
+  if (!buckets || buckets.length === 0) {
+    logger.warn(
+      `[ros-mobile-bridge] presetOverrides.${mode}: empty bucket array; using default preset for this mode`
+    );
+    return false;
+  }
+  const first = buckets[0];
+  if (!first || first.threshold !== 0) {
+    logger.warn(
+      `[ros-mobile-bridge] presetOverrides.${mode}: first bucket must have threshold === 0 (the "no throttle" base case); using default preset for this mode`
+    );
+    return false;
+  }
+  return true;
+}
+function buildEffectivePresets(overrides, logger) {
+  const merged = {
+    performance: DEFAULT_PRESETS.performance,
+    auto: DEFAULT_PRESETS.auto,
+    efficient: DEFAULT_PRESETS.efficient
+  };
+  if (!overrides) return merged;
+  for (const mode of THROTTLE_MODES) {
+    const override = overrides[mode];
+    if (override === void 0) continue;
+    if (validatePreset(override, mode, logger)) {
+      merged[mode] = override;
+    }
+  }
+  return merged;
+}
+function createBandwidthTracker(mode = "auto", presets = DEFAULT_PRESETS) {
+  const initialBucket = INITIAL_BUCKET_PER_MODE[mode] ?? 0;
+  const preset = presets[mode];
+  const safeInitial = Math.min(initialBucket, Math.max(0, preset.length - 1));
+  const initialIntervalMs = preset[safeInitial]?.minIntervalMs ?? 0;
+  return {
+    window: [],
+    bytesPerSec: 0,
+    currentBucket: safeInitial,
+    targetBucket: safeInitial,
+    targetObservedAt: 0,
+    adaptiveMinIntervalMs: initialIntervalMs,
+    presets
+  };
+}
+function recordBytes(tracker, now, byteSize, mode = "auto") {
+  tracker.window.push({ t: now, b: byteSize });
+  const cutoff = now - BANDWIDTH_WINDOW_MS;
+  while (tracker.window.length > 0) {
+    const head = tracker.window[0];
+    if (!head || head.t >= cutoff) break;
+    tracker.window.shift();
+  }
+  let total = 0;
+  for (const e of tracker.window) total += e.b;
+  tracker.bytesPerSec = total / (BANDWIDTH_WINDOW_MS / 1e3);
+  const buckets = tracker.presets[mode];
+  const lagMs = getMaxLagMs();
+  let targetBucket = 0;
+  for (let i = buckets.length - 1; i >= 1; i--) {
+    const bucket = buckets[i];
+    if (bucket && lagMs >= bucket.threshold) {
+      targetBucket = i;
+      break;
+    }
+  }
+  if (targetBucket !== tracker.targetBucket) {
+    tracker.targetBucket = targetBucket;
+    tracker.targetObservedAt = now;
+    return;
+  }
+  if (targetBucket === tracker.currentBucket) {
+    return;
+  }
+  const dwell = now - tracker.targetObservedAt;
+  const tighten = targetBucket > tracker.currentBucket;
+  const requiredDwell = tighten ? TIGHTEN_DWELL_MS : RELAX_DWELL_MS;
+  if (dwell < requiredDwell) return;
+  if (tighten) {
+    tracker.currentBucket = targetBucket;
+  } else {
+    tracker.currentBucket = Math.max(targetBucket, tracker.currentBucket - 1);
+    tracker.targetObservedAt = now;
+  }
+  tracker.adaptiveMinIntervalMs = buckets[tracker.currentBucket]?.minIntervalMs ?? 0;
+}
+function effectiveMinInterval(userMinIntervalMs, disableAdaptive, tracker) {
+  const user = userMinIntervalMs ?? 0;
+  if (disableAdaptive) return user;
+  return Math.max(user, tracker.adaptiveMinIntervalMs);
+}
+function setTrackerToDeepest(tracker, mode) {
+  const buckets = tracker.presets[mode];
+  const lastIdx = Math.max(0, buckets.length - 1);
+  tracker.currentBucket = lastIdx;
+  tracker.targetBucket = lastIdx;
+  tracker.targetObservedAt = 0;
+  tracker.adaptiveMinIntervalMs = buckets[lastIdx]?.minIntervalMs ?? 0;
+}
+function getTrackerBucketLabel(tracker, mode) {
+  const buckets = tracker.presets[mode];
+  return buckets[tracker.currentBucket]?.label ?? "none";
+}
+function bucketLabelForLag(mode, lagMs) {
+  const buckets = DEFAULT_PRESETS[mode];
+  let idx = 0;
+  for (let i = buckets.length - 1; i >= 1; i--) {
+    const bucket = buckets[i];
+    if (bucket && lagMs >= bucket.threshold) {
+      idx = i;
+      break;
+    }
+  }
+  return buckets[idx]?.label ?? "none";
+}
+
+// src/schemaToTemplate.ts
+var PRIMITIVE_DEFAULTS = {
+  bool: false,
+  int8: 0,
+  uint8: 0,
+  int16: 0,
+  uint16: 0,
+  int32: 0,
+  uint32: 0,
+  int64: 0,
+  uint64: 0,
+  float32: 0,
+  float64: 0,
+  string: "",
+  wstring: "",
+  time: { sec: 0, nsec: 0 },
+  duration: { sec: 0, nsec: 0 },
+  "builtin_interfaces/Time": { sec: 0, nanosec: 0 },
+  "builtin_interfaces/Duration": { sec: 0, nanosec: 0 },
+  "builtin_interfaces/msg/Time": { sec: 0, nanosec: 0 },
+  "builtin_interfaces/msg/Duration": { sec: 0, nanosec: 0 }
+};
+function schemaToTemplate(definitions) {
+  if (!definitions.length) return {};
+  const typeMap = /* @__PURE__ */ new Map();
+  for (const def of definitions) {
+    if (def.name) {
+      typeMap.set(def.name, def);
+    }
+  }
+  const root = definitions[0];
+  if (!root) return {};
+  return buildObject(root, typeMap, 0);
+}
+function buildObject(def, typeMap, depth) {
+  if (depth > 10) return {};
+  const result = {};
+  for (const field of def.definitions) {
+    if (field.isConstant) continue;
+    const defaultVal = getFieldDefault(field.type, field.isComplex, typeMap, depth);
+    if (field.isArray) {
+      result[field.name] = [];
+    } else {
+      result[field.name] = defaultVal;
+    }
+  }
+  return result;
+}
+function getFieldDefault(typeName, isComplex, typeMap, depth) {
+  if (PRIMITIVE_DEFAULTS[typeName] !== void 0) {
+    const val = PRIMITIVE_DEFAULTS[typeName];
+    return typeof val === "object" ? JSON.parse(JSON.stringify(val)) : val;
+  }
+  if (isComplex) {
+    const subDef = typeMap.get(typeName);
+    if (subDef) {
+      return buildObject(subDef, typeMap, depth + 1);
+    }
+    for (const [key, def] of typeMap) {
+      if (key.endsWith(`/${typeName}`) || typeName.endsWith(`/${key}`)) {
+        return buildObject(def, typeMap, depth + 1);
+      }
+    }
+  }
+  return "";
+}
+
+// src/jsonSchemaToTemplate.ts
+function jsonSchemaToTemplate(schema) {
+  if (!schema || typeof schema !== "object" || Array.isArray(schema)) return null;
+  const s = schema;
+  if ("default" in s) return s.default;
+  const type = s.type;
+  if (type === "object") {
+    const props = s.properties;
+    if (!props || typeof props !== "object" || Array.isArray(props)) return {};
+    const result = {};
+    for (const [key, sub] of Object.entries(props)) {
+      result[key] = jsonSchemaToTemplate(sub);
+    }
+    return result;
+  }
+  if (type === "array") {
+    return [];
+  }
+  if (type === "string") return "";
+  if (type === "number" || type === "integer") return 0;
+  if (type === "boolean") return false;
+  if (type === "null") return null;
+  if (Array.isArray(type)) {
+    const first = type.find((t) => t !== "null") ?? type[0];
+    return jsonSchemaToTemplate({ ...s, type: first });
+  }
+  return null;
+}
+
+// src/FoxgloveClient.ts
+var NOOP_LOGGER = { log() {
+}, warn() {
+}, error() {
+} };
+var TEXT_ENCODER = new TextEncoder();
+var TEXT_DECODER = new TextDecoder();
+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;
+var ZERO_TWIST = {
+  linear: { x: 0, y: 0, z: 0 },
+  angular: { x: 0, y: 0, z: 0 }
+};
+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");
+    __publicField(this, "ws", null);
+    __publicField(this, "url", "");
+    __publicField(this, "status", "disconnected");
+    __publicField(this, "statusListeners", /* @__PURE__ */ new Set());
+    __publicField(this, "logListeners", /* @__PURE__ */ new Set());
+    __publicField(this, "topicsListeners", /* @__PURE__ */ new Set());
+    __publicField(this, "servicesListeners", /* @__PURE__ */ new Set());
+    // Channel state
+    __publicField(this, "channels", /* @__PURE__ */ new Map());
+    __publicField(this, "topicToChannelId", /* @__PURE__ */ new Map());
+    // Per-subscription state. Each callback keeps its own throttle clock so
+    // multi-subscriber topics with different `maxFrequency` settings stay
+    // isolated. Bandwidth tracking is per-subscription and feeds the adaptive
+    // throttle layered on top of per-callback `maxFrequency`.
+    __publicField(this, "nextSubscriptionId", 1);
+    __publicField(this, "subscriptions", /* @__PURE__ */ new Map());
+    __publicField(this, "topicToSubscriptionId", /* @__PURE__ */ new Map());
+    __publicField(this, "breakerListeners", /* @__PURE__ */ new Map());
+    // CDR message readers — keyed by subscriptionId, created from channel schema.
+    __publicField(this, "messageReaders", /* @__PURE__ */ new Map());
+    // Publish state — maps topic → client-advertised channelId.
+    __publicField(this, "nextClientChannelId", 1);
+    __publicField(this, "advertisedTopics", /* @__PURE__ */ new Map());
+    __publicField(this, "hasPublishedTwist", false);
+    __publicField(this, "controlOutbox", []);
+    __publicField(this, "controlFlushScheduled", false);
+    // Service calls
+    __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);
+    // Reconnection
+    __publicField(this, "reconnectAttempts", 0);
+    __publicField(this, "reconnectTimer", null);
+    __publicField(this, "connectionTimeoutTimer", null);
+    __publicField(this, "intentionalDisconnect", false);
+    // Connection handshake
+    __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);
+    setModeGetter(this.getThrottleMode);
+  }
+  get isConnected() {
+    return this.status === "connected";
+  }
+  get reconnectAttempt() {
+    return this.reconnectAttempts;
+  }
+  get maxReconnectAttempts() {
+    return MAX_RECONNECT_ATTEMPTS;
+  }
+  async connect(url) {
+    if (this.status === "connecting" || this.status === "connected") {
+      return;
+    }
+    this.url = url.trim();
+    this.intentionalDisconnect = false;
+    this.reconnectAttempts = 0;
+    this.log(`Opening WebSocket to ${this.url}...`);
+    return this.performConnect();
+  }
+  async disconnect() {
+    this.intentionalDisconnect = true;
+    this.safePublishZeroTwist();
+    this.flushControlOutbox();
+    this.cleanup();
+    this.setStatus("disconnected");
+  }
+  async getAvailableTopics() {
+    const appTopics = new Set(this.advertisedTopics.keys());
+    return Array.from(this.channels.values()).map((ch) => ({
+      topic: ch.topic,
+      schemaName: ch.schemaName,
+      encoding: ch.encoding,
+      source: appTopics.has(ch.topic) ? "app" : "robot"
+    }));
+  }
+  getSchemaTemplate(schemaName) {
+    for (const ch of this.channels.values()) {
+      if (ch.schemaName !== schemaName || !ch.schema) continue;
+      const encoding = (ch.schemaEncoding ?? "").toLowerCase();
+      const schemaStr = ch.schema;
+      const looksLikeJsonSchema = schemaStr.trimStart().startsWith("{");
+      const tryRos2idl = () => {
+        try {
+          return schemaToTemplate(ros2idlParser.parseRos2idl(schemaStr));
+        } catch {
+          return null;
+        }
+      };
+      const tryRos2msg = () => {
+        try {
+          return schemaToTemplate(rosmsg.parse(schemaStr, { ros2: true }));
+        } catch {
+          return null;
+        }
+      };
+      const tryJsonSchema = () => {
+        try {
+          const parsed = JSON.parse(schemaStr);
+          const t = jsonSchemaToTemplate(parsed);
+          return t && typeof t === "object" && !Array.isArray(t) ? t : null;
+        } catch {
+          return null;
+        }
+      };
+      let order;
+      if (encoding === "ros2idl") {
+        order = [tryRos2idl, tryJsonSchema, tryRos2msg];
+      } else if (encoding === "jsonschema" || looksLikeJsonSchema) {
+        order = [tryJsonSchema, tryRos2idl, tryRos2msg];
+      } else {
+        order = [tryRos2msg, tryRos2idl, tryJsonSchema];
+      }
+      for (const attempt of order) {
+        const t = attempt();
+        if (t) return t;
+      }
+      this.log(
+        `Schema template parse failed for "${schemaName}" \u2014 all parsers rejected the schema.`
+      );
+      break;
+    }
+    return null;
+  }
+  subscribe(topic, onMessage, options) {
+    const userMinIntervalMs = options?.maxFrequency && options.maxFrequency > 0 ? 1e3 / options.maxFrequency : void 0;
+    const disableAdaptive = options?.disableAdaptive ?? false;
+    const existingSubId = this.topicToSubscriptionId.get(topic);
+    if (existingSubId !== void 0) {
+      const sub = this.subscriptions.get(existingSubId);
+      if (sub) {
+        sub.callbacks.set(onMessage, {
+          userMinIntervalMs,
+          disableAdaptive,
+          lastDeliveredAt: 0
+        });
+        return () => {
+          sub.callbacks.delete(onMessage);
+          if (sub.callbacks.size === 0) {
+            this.unsubscribeTopic(topic, existingSubId);
+          }
+        };
+      }
+    }
+    const channelId = this.topicToChannelId.get(topic);
+    if (channelId === void 0) {
+      this.logger.warn(
+        `[FoxgloveClient] Topic "${topic}" not available. Available: ${Array.from(this.topicToChannelId.keys()).join(", ")}`
+      );
+      return () => {
+      };
+    }
+    const subscriptionId = this.nextSubscriptionId++;
+    const callbacks = /* @__PURE__ */ new Map();
+    callbacks.set(onMessage, {
+      userMinIntervalMs,
+      disableAdaptive,
+      lastDeliveredAt: 0
+    });
+    const breaker = new CircuitBreaker({
+      ...DEFAULT_BREAKER_CONFIG,
+      onStateChange: (newState) => {
+        const sub = this.subscriptions.get(subscriptionId);
+        if (!sub) return;
+        sub.isPaused = newState === "tripped_auto" || newState === "tripped_manual";
+        if (newState === "tripped_auto") {
+          if (this.ws && this.status === "connected") {
+            this.sendJson({ op: "unsubscribe", subscriptionIds: [subscriptionId] });
+          }
+          this.log(`[breaker] ${topic} \u2192 tripped_auto (sustained overload)`);
+        } else if (newState === "half_open") {
+          setTrackerToDeepest(sub.bandwidth, this.getThrottleMode());
+          if (this.ws && this.status === "connected") {
+            this.sendJson({
+              op: "subscribe",
+              subscriptions: [{ id: subscriptionId, channelId: sub.channelId }]
+            });
+          }
+          this.log(`[breaker] ${topic} \u2192 half_open (re-subscribed)`);
+        } else if (newState === "closed") {
+          this.log(`[breaker] ${topic} \u2192 closed (recovered)`);
+        } else if (newState === "tripped_manual") {
+          this.log(`[breaker] ${topic} \u2192 tripped_manual (user disabled auto-retry)`);
+        }
+        const listeners = this.breakerListeners.get(topic);
+        if (listeners) {
+          for (const cb of listeners) {
+            try {
+              cb(newState);
+            } catch (err) {
+              this.logger.error("[FoxgloveClient] Breaker listener error:", err);
+            }
+          }
+        }
+      }
+    });
+    this.subscriptions.set(subscriptionId, {
+      topic,
+      channelId,
+      callbacks,
+      bandwidth: createBandwidthTracker(this.getThrottleMode(), this.presets),
+      breaker,
+      isPaused: false
+    });
+    this.topicToSubscriptionId.set(topic, subscriptionId);
+    const channel = this.channels.get(channelId);
+    if (channel && channel.schema && channel.encoding !== "json") {
+      const schemaEncoding = channel.schemaEncoding ?? "";
+      this.log(
+        `Creating CDR reader for "${topic}" (encoding=${channel.encoding}, schemaEncoding=${schemaEncoding})`
+      );
+      try {
+        let msgDefs;
+        if (schemaEncoding === "ros2idl") {
+          msgDefs = ros2idlParser.parseRos2idl(channel.schema);
+        } else {
+          msgDefs = rosmsg.parse(channel.schema, { ros2: true });
+        }
+        this.messageReaders.set(subscriptionId, new rosmsg2Serialization.MessageReader(msgDefs));
+        this.log(`  CDR reader created successfully for "${topic}"`);
+      } catch (err) {
+        this.log(`  CDR reader FAILED for "${topic}": ${String(err)}`);
+        this.log(`  Schema preview: ${channel.schema.substring(0, 200)}`);
+      }
+    }
+    this.sendJson({
+      op: "subscribe",
+      subscriptions: [{ id: subscriptionId, channelId }]
+    });
+    return () => {
+      callbacks.delete(onMessage);
+      if (callbacks.size === 0) {
+        this.unsubscribeTopic(topic, subscriptionId);
+      }
+    };
+  }
+  publish(topic, schemaName, data, options) {
+    if (!this.ws || this.status !== "connected") {
+      return;
+    }
+    if (schemaName === CMD_VEL_SCHEMA) {
+      this.hasPublishedTwist = true;
+    }
+    let clientChannelId = this.advertisedTopics.get(topic);
+    if (clientChannelId === void 0) {
+      clientChannelId = this.nextClientChannelId++;
+      this.advertisedTopics.set(topic, clientChannelId);
+      this.sendJson({
+        op: "advertise",
+        channels: [
+          {
+            id: clientChannelId,
+            topic,
+            encoding: "json",
+            schemaName
+          }
+        ]
+      });
+      const chId = clientChannelId;
+      setTimeout(() => {
+        this.sendBinaryMessage(chId, data);
+      }, 150);
+      return;
+    }
+    if (options?.priority === "control") {
+      this.controlOutbox.push({ channelId: clientChannelId, data });
+      this.scheduleControlFlush();
+      return;
+    }
+    this.sendBinaryMessage(clientChannelId, data);
+  }
+  scheduleControlFlush() {
+    if (this.controlFlushScheduled) return;
+    this.controlFlushScheduled = true;
+    setTimeout(() => {
+      this.controlFlushScheduled = false;
+      this.flushControlOutbox();
+    }, 0);
+  }
+  flushControlOutbox() {
+    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+      this.controlOutbox.length = 0;
+      return;
+    }
+    let drained = 0;
+    while (this.controlOutbox.length > 0 && drained < _FoxgloveClient.CONTROL_FLUSH_BATCH) {
+      const entry = this.controlOutbox.shift();
+      if (!entry) break;
+      this.sendBinaryMessage(entry.channelId, entry.data);
+      drained++;
+    }
+    if (this.controlOutbox.length > 0) {
+      this.scheduleControlFlush();
+    }
+  }
+  ensureAdvertised(topic, schemaName) {
+    if (!this.ws || this.status !== "connected") return;
+    if (this.advertisedTopics.has(topic)) return;
+    const clientChannelId = this.nextClientChannelId++;
+    this.advertisedTopics.set(topic, clientChannelId);
+    this.sendJson({
+      op: "advertise",
+      channels: [
+        {
+          id: clientChannelId,
+          topic,
+          encoding: "json",
+          schemaName
+        }
+      ]
+    });
+  }
+  unadvertise(topic) {
+    const clientChannelId = this.advertisedTopics.get(topic);
+    if (clientChannelId === void 0) return;
+    this.advertisedTopics.delete(topic);
+    if (this.ws && this.status === "connected") {
+      this.sendJson({
+        op: "unadvertise",
+        channelIds: [clientChannelId]
+      });
+    }
+  }
+  sendBinaryMessage(channelId, data) {
+    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) return;
+    const jsonPayload = JSON.stringify(data);
+    const payloadBytes = TEXT_ENCODER.encode(jsonPayload);
+    const buffer = new ArrayBuffer(1 + 4 + payloadBytes.byteLength);
+    const view = new DataView(buffer);
+    view.setUint8(0, 1 /* MESSAGE_DATA */);
+    view.setUint32(1, channelId, true);
+    new Uint8Array(buffer, 5).set(payloadBytes);
+    this.ws.send(buffer);
+  }
+  async callService(service, request) {
+    if (!this.ws || this.status !== "connected") {
+      throw new Error("Not connected");
+    }
+    const serviceInfo = this.availableServices.get(service);
+    if (!serviceInfo) {
+      throw new Error(`Service "${service}" not available`);
+    }
+    const callId = this.nextServiceCallId++;
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.pendingServiceCalls.delete(callId);
+        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
+      });
+    });
+  }
+  onStatusChange(cb) {
+    this.statusListeners.add(cb);
+    cb(this.status);
+    return () => {
+      this.statusListeners.delete(cb);
+    };
+  }
+  onTopicsChange(cb) {
+    this.topicsListeners.add(cb);
+    return () => {
+      this.topicsListeners.delete(cb);
+    };
+  }
+  getAvailableServices() {
+    return Array.from(this.availableServices.values()).map((s) => ({
+      name: s.name,
+      type: s.type
+    }));
+  }
+  onServicesChange(cb) {
+    this.servicesListeners.add(cb);
+    cb(this.getAvailableServices());
+    return () => {
+      this.servicesListeners.delete(cb);
+    };
+  }
+  onLog(cb) {
+    this.logListeners.add(cb);
+    return () => {
+      this.logListeners.delete(cb);
+    };
+  }
+  publishZeroTwist() {
+    this.safePublishZeroTwist();
+  }
+  // ── Private: connection lifecycle ────────────────────────────────────────
+  performConnect() {
+    this.cleanup();
+    this.setStatus("connecting");
+    return new Promise((resolve, reject) => {
+      this.connectResolve = resolve;
+      this.connectReject = reject;
+      try {
+        this.ws = new WebSocket(this.url, SUBPROTOCOLS);
+        this.ws.binaryType = "arraybuffer";
+        this.ws.onopen = () => {
+          const negotiated = this.ws?.protocol ?? "unknown";
+          this.log(
+            `WebSocket handshake successful (protocol: ${negotiated}), waiting for serverInfo...`
+          );
+          this.clearConnectionTimeout();
+        };
+        this.ws.onmessage = (event) => {
+          this.handleWsMessage(event);
+        };
+        this.ws.onerror = (event) => {
+          const detail = event.message ?? "Handshake failed or connection rejected by server";
+          this.log(`WebSocket error: ${detail}`);
+          this.logger.error("[FoxgloveClient] WebSocket error:", event);
+          this.handleConnectionError(new Error(`WebSocket error: ${detail}`));
+        };
+        this.ws.onclose = (event) => {
+          this.log(`WebSocket closed: code=${event.code}, reason=${event.reason || "none"}`);
+          this.handleClose(event.code ?? 1e3, event.reason ?? "");
+        };
+        this.connectionTimeoutTimer = setTimeout(() => {
+          this.handleConnectionError(
+            new Error(`Connection timeout after ${CONNECTION_TIMEOUT_MS}ms`)
+          );
+        }, CONNECTION_TIMEOUT_MS);
+      } catch (err) {
+        this.handleConnectionError(err instanceof Error ? err : new Error(String(err)));
+      }
+    });
+  }
+  // ── Private: WebSocket message handling ──────────────────────────────────
+  handleWsMessage(event) {
+    if (this.controlOutbox.length > 0) {
+      this.flushControlOutbox();
+    }
+    if (typeof event.data === "string") {
+      this.handleJsonMessage(event.data);
+    } else if (event.data instanceof ArrayBuffer) {
+      this.handleBinaryMessage(event.data);
+    }
+  }
+  handleJsonMessage(raw) {
+    let msg;
+    try {
+      msg = JSON.parse(raw);
+    } catch {
+      this.logger.warn("[FoxgloveClient] Failed to parse JSON message");
+      return;
+    }
+    switch (msg.op) {
+      case "serverInfo":
+        this.handleServerInfo(msg);
+        break;
+      case "advertise":
+        this.handleAdvertise(msg);
+        break;
+      case "unadvertise":
+        this.handleUnadvertise(msg);
+        break;
+      case "advertiseServices":
+        this.handleAdvertiseServices(msg);
+        break;
+      case "serviceCallResponse":
+        this.handleServiceCallResponse(msg);
+        break;
+      case "pong":
+        this.handlePong();
+        break;
+      case "schemas":
+        break;
+      case "status":
+        if (msg.level === 2) {
+          this.logger.error(
+            "[FoxgloveClient] Server error:",
+            msg.message
+          );
+        }
+        break;
+    }
+  }
+  handleBinaryMessage(buffer) {
+    if (buffer.byteLength < 5) return;
+    const view = new DataView(buffer);
+    const opcode = view.getUint8(0);
+    if (opcode !== 1 /* MESSAGE_DATA */) return;
+    const subscriptionId = view.getUint32(1, true);
+    const timestampLow = view.getUint32(5, true);
+    const timestampHigh = view.getUint32(9, true);
+    const timestampNs = timestampHigh * 4294967296 + timestampLow;
+    const sec = Math.floor(timestampNs / 1e9);
+    const nsec = timestampNs % 1e9;
+    const payloadOffset = 13;
+    const payload = buffer.slice(payloadOffset);
+    const sub = this.subscriptions.get(subscriptionId);
+    if (!sub) return;
+    if (sub.isPaused) return;
+    const now = Date.now();
+    const mode = this.getThrottleMode();
+    recordBytes(sub.bandwidth, now, buffer.byteLength, mode);
+    sub.breaker.recordObservation(now, sub.bandwidth.bytesPerSec, getMaxLagMs());
+    const deliverTo = [];
+    for (const [cb, entry] of sub.callbacks) {
+      const interval = effectiveMinInterval(
+        entry.userMinIntervalMs,
+        entry.disableAdaptive,
+        sub.bandwidth
+      );
+      if (interval <= 0 || now - entry.lastDeliveredAt >= interval) {
+        deliverTo.push([cb, entry]);
+      }
+    }
+    if (deliverTo.length === 0) return;
+    const channelInfo = this.channels.get(sub.channelId);
+    const schemaName = channelInfo?.schemaName ?? "";
+    const encoding = channelInfo?.encoding ?? "json";
+    let data;
+    if (encoding === "json") {
+      try {
+        const text = TEXT_DECODER.decode(payload);
+        data = JSON.parse(text);
+      } catch {
+        data = new Uint8Array(payload);
+      }
+    } else {
+      const reader = this.messageReaders.get(subscriptionId);
+      if (reader) {
+        try {
+          data = reader.readMessage(new Uint8Array(payload));
+        } catch {
+          data = new Uint8Array(payload);
+        }
+      } else {
+        data = new Uint8Array(payload);
+      }
+    }
+    const rosMsg = {
+      topic: sub.topic,
+      schemaName,
+      encoding: encoding === "json" ? "json" : "cdr",
+      data,
+      receiveTime: { sec, nsec },
+      byteSize: payload.byteLength
+    };
+    for (const [cb, entry] of deliverTo) {
+      entry.lastDeliveredAt = now;
+      try {
+        cb(rosMsg);
+      } catch (err) {
+        this.logger.error("[FoxgloveClient] Subscriber callback error:", err);
+      }
+    }
+  }
+  handleServerInfo(info) {
+    this.log(`Received serverInfo: ${info.name} (sessionId: ${info.sessionId ?? "none"})`);
+    this.serverInfoReceived = true;
+  }
+  handleAdvertise(msg) {
+    for (const ch of msg.channels) {
+      this.channels.set(ch.id, ch);
+      this.topicToChannelId.set(ch.topic, ch.id);
+      this.log(
+        `  Channel: ${ch.topic} [${ch.schemaName}] encoding=${ch.encoding} schemaEncoding=${ch.schemaEncoding ?? "none"}`
+      );
+    }
+    if (this.connectResolve && this.serverInfoReceived) {
+      this.log(`Connection established with ${msg.channels.length} initial topics.`);
+      this.clearConnectionTimeout();
+      this.reconnectAttempts = 0;
+      this.setStatus("connected");
+      this.startPingLoop();
+      this.connectResolve();
+      this.connectResolve = null;
+      this.connectReject = null;
+    } else {
+      this.notifyTopicsChanged();
+    }
+  }
+  handleUnadvertise(msg) {
+    for (const id of msg.channelIds) {
+      const ch = this.channels.get(id);
+      if (ch) {
+        this.topicToChannelId.delete(ch.topic);
+      }
+      this.channels.delete(id);
+    }
+    this.notifyTopicsChanged();
+  }
+  handleAdvertiseServices(msg) {
+    for (const svc of msg.services) {
+      this.availableServices.set(svc.name, svc);
+    }
+    this.notifyServicesChanged();
+  }
+  notifyServicesChanged() {
+    const snapshot = this.getAvailableServices();
+    for (const cb of this.servicesListeners) {
+      try {
+        cb(snapshot);
+      } catch (err) {
+        this.logger.error("[FoxgloveClient] Services listener error:", err);
+      }
+    }
+  }
+  handleServiceCallResponse(msg) {
+    const pending = this.pendingServiceCalls.get(msg.callId);
+    if (!pending) return;
+    clearTimeout(pending.timer);
+    this.pendingServiceCalls.delete(msg.callId);
+    try {
+      if (msg.encoding === "json" && msg.data) {
+        const decoded = atob(msg.data);
+        const parsed = JSON.parse(decoded);
+        pending.resolve(parsed);
+      } else {
+        pending.resolve({ success: true });
+      }
+    } catch (err) {
+      pending.reject(
+        new Error(
+          `Failed to parse service response: ${err instanceof Error ? err.message : String(err)}`
+        )
+      );
+    }
+  }
+  // ── 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);
+  }
+  stopPingLoop() {
+    if (this.pingTimer) {
+      clearInterval(this.pingTimer);
+      this.pingTimer = null;
+    }
+    if (this.pongTimer) {
+      clearTimeout(this.pongTimer);
+      this.pongTimer = null;
+    }
+  }
+  handlePong() {
+    if (this.pongTimer) {
+      clearTimeout(this.pongTimer);
+      this.pongTimer = null;
+    }
+    if (this.onLatency && this.lastPingSentTime > 0) {
+      try {
+        this.onLatency(Date.now() - this.lastPingSentTime);
+      } catch {
+      }
+    }
+  }
+  // ── Private: reconnection ────────────────────────────────────────────────
+  handleConnectionError(error) {
+    this.clearConnectionTimeout();
+    if (this.connectReject) {
+      this.connectReject(error);
+      this.connectResolve = null;
+      this.connectReject = null;
+    }
+    this.setStatus("error");
+    this.cleanup();
+    this.scheduleReconnect();
+  }
+  handleClose(_code, _reason) {
+    const wasConnected = this.status === "connected";
+    if (wasConnected && this.hasPublishedTwist && !this.intentionalDisconnect) {
+      this.safePublishZeroTwist();
+    }
+    this.cleanup();
+    this.setStatus("disconnected");
+    if (wasConnected && !this.intentionalDisconnect) {
+      this.scheduleReconnect();
+    }
+  }
+  scheduleReconnect() {
+    if (this.intentionalDisconnect || this.reconnectTimer !== null || this.reconnectAttempts >= MAX_RECONNECT_ATTEMPTS) {
+      if (this.reconnectAttempts >= MAX_RECONNECT_ATTEMPTS) {
+        this.logger.warn(
+          `[FoxgloveClient] Max reconnect attempts (${MAX_RECONNECT_ATTEMPTS}) reached`
+        );
+        this.setStatus("error");
+      }
+      return;
+    }
+    const delay = Math.min(
+      BASE_RECONNECT_DELAY_MS * Math.pow(2, this.reconnectAttempts),
+      16e3
+    );
+    this.log(
+      `Scheduling reconnect attempt ${this.reconnectAttempts + 1}/${MAX_RECONNECT_ATTEMPTS} in ${delay}ms...`
+    );
+    this.reconnectAttempts++;
+    this.reconnectTimer = setTimeout(() => {
+      this.reconnectTimer = null;
+      this.performConnect().catch((err) => {
+        this.logger.error("[FoxgloveClient] Reconnect failed:", err);
+      });
+    }, delay);
+  }
+  // ── Private: unsubscribe ─────────────────────────────────────────────────
+  unsubscribeTopic(topic, subscriptionId) {
+    const sub = this.subscriptions.get(subscriptionId);
+    sub?.breaker.destroy();
+    this.subscriptions.delete(subscriptionId);
+    this.topicToSubscriptionId.delete(topic);
+    this.messageReaders.delete(subscriptionId);
+    if (this.ws && this.status === "connected" && !sub?.isPaused) {
+      this.sendJson({
+        op: "unsubscribe",
+        subscriptionIds: [subscriptionId]
+      });
+    }
+  }
+  // ── IProtocolClient: circuit breaker controls ─────────────────────────────
+  getBreakerState(topic) {
+    const subId = this.topicToSubscriptionId.get(topic);
+    if (subId === void 0) return "closed";
+    const sub = this.subscriptions.get(subId);
+    return sub?.breaker.getState() ?? "closed";
+  }
+  getBreakerNextRetryAt(topic) {
+    const subId = this.topicToSubscriptionId.get(topic);
+    if (subId === void 0) return null;
+    return this.subscriptions.get(subId)?.breaker.getNextRetryAt() ?? null;
+  }
+  getSubscriptionStats(topic) {
+    const subId = this.topicToSubscriptionId.get(topic);
+    if (subId === void 0) return null;
+    const sub = this.subscriptions.get(subId);
+    if (!sub) return null;
+    const mode = this.getThrottleMode();
+    return {
+      adaptiveMinIntervalMs: sub.bandwidth.adaptiveMinIntervalMs,
+      bucketLabel: getTrackerBucketLabel(sub.bandwidth, mode),
+      bytesPerSec: sub.bandwidth.bytesPerSec
+    };
+  }
+  breakerRetry(topic) {
+    const subId = this.topicToSubscriptionId.get(topic);
+    if (subId === void 0) return;
+    this.subscriptions.get(subId)?.breaker.retry();
+  }
+  breakerDisable(topic) {
+    const subId = this.topicToSubscriptionId.get(topic);
+    if (subId === void 0) return;
+    this.subscriptions.get(subId)?.breaker.disable();
+  }
+  onBreakerStateChange(topic, cb) {
+    let listeners = this.breakerListeners.get(topic);
+    if (!listeners) {
+      listeners = /* @__PURE__ */ new Set();
+      this.breakerListeners.set(topic, listeners);
+    }
+    listeners.add(cb);
+    return () => {
+      const set = this.breakerListeners.get(topic);
+      if (set) {
+        set.delete(cb);
+        if (set.size === 0) this.breakerListeners.delete(topic);
+      }
+    };
+  }
+  // ── Private: dead-man's switch ───────────────────────────────────────────
+  safePublishZeroTwist() {
+    if (!this.hasPublishedTwist) return;
+    try {
+      if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+        this.publish("/cmd_vel", CMD_VEL_SCHEMA, ZERO_TWIST, { priority: "control" });
+      }
+    } catch {
+    }
+    this.hasPublishedTwist = false;
+  }
+  // ── 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();
+    if (this.ws) {
+      if (this.ws.readyState === WebSocket.OPEN && this.advertisedTopics.size > 0) {
+        const channelIds = Array.from(this.advertisedTopics.values());
+        try {
+          this.sendJson({ op: "unadvertise", channelIds });
+        } catch {
+        }
+      }
+      this.ws.onopen = null;
+      this.ws.onmessage = null;
+      this.ws.onerror = null;
+      this.ws.onclose = null;
+      if (this.ws.readyState === WebSocket.OPEN || this.ws.readyState === WebSocket.CONNECTING) {
+        this.ws.close();
+      }
+      this.ws = null;
+    }
+    this.channels.clear();
+    this.topicToChannelId.clear();
+    this.subscriptions.clear();
+    this.topicToSubscriptionId.clear();
+    this.messageReaders.clear();
+    this.advertisedTopics.clear();
+    this.availableServices.clear();
+    this.notifyServicesChanged();
+    this.serverInfoReceived = false;
+    this.nextSubscriptionId = 1;
+    this.nextClientChannelId = 1;
+    this.nextServiceCallId = 1;
+  }
+  clearConnectionTimeout() {
+    if (this.connectionTimeoutTimer) {
+      clearTimeout(this.connectionTimeoutTimer);
+      this.connectionTimeoutTimer = null;
+    }
+  }
+  // ── Private: helpers ─────────────────────────────────────────────────────
+  setStatus(status) {
+    if (this.status === status) return;
+    this.status = status;
+    for (const cb of this.statusListeners) {
+      try {
+        cb(status);
+      } catch (err) {
+        this.logger.error("[FoxgloveClient] Status listener error:", err);
+      }
+    }
+  }
+  sendJson(msg) {
+    if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+      this.ws.send(JSON.stringify(msg));
+    }
+  }
+  notifyTopicsChanged() {
+    const appTopics = new Set(this.advertisedTopics.keys());
+    const topics = Array.from(this.channels.values()).map((ch) => ({
+      topic: ch.topic,
+      schemaName: ch.schemaName,
+      encoding: ch.encoding,
+      source: appTopics.has(ch.topic) ? "app" : "robot"
+    }));
+    for (const cb of this.topicsListeners) {
+      try {
+        cb(topics);
+      } catch (err) {
+        this.logger.error("[FoxgloveClient] Topics listener error:", err);
+      }
+    }
+  }
+  log(message) {
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString().substring(11, 23);
+    const formatted = `[${timestamp}] ${message}`;
+    this.logger.log(`[FoxgloveClient] ${formatted}`);
+    for (const cb of this.logListeners) {
+      try {
+        cb(formatted);
+      } catch (err) {
+        this.logger.error("[FoxgloveClient] Log listener error:", err);
+      }
+    }
+  }
+};
+// Control-priority outbox. Twist / E-Stop publishes route through here
+// and get flushed at the top of every incoming WS message handler.
+__publicField(_FoxgloveClient, "CONTROL_FLUSH_BATCH", 3);
+var FoxgloveClient = _FoxgloveClient;
+
+// src/RosbridgeClient.ts
+var NOOP_LOGGER2 = { log() {
+}, warn() {
+}, error() {
+} };
+var TEXT_DECODER2 = new TextDecoder();
+var MAX_RECONNECT_ATTEMPTS2 = 5;
+var BASE_RECONNECT_DELAY_MS2 = 1e3;
+var CONNECTION_TIMEOUT_MS2 = 1e4;
+var DEFAULT_THROTTLE_RATE_MS = 100;
+var SERVICE_CALL_TIMEOUT_MS = 3e4;
+var ZERO_TWIST2 = {
+  linear: { x: 0, y: 0, z: 0 },
+  angular: { x: 0, y: 0, z: 0 }
+};
+var CMD_VEL_SCHEMA2 = "geometry_msgs/msg/Twist";
+var _RosbridgeClient = class _RosbridgeClient {
+  constructor(options) {
+    __publicField(this, "onLatency");
+    __publicField(this, "logger");
+    __publicField(this, "getThrottleMode");
+    __publicField(this, "presets");
+    __publicField(this, "ws", null);
+    __publicField(this, "url", "");
+    __publicField(this, "status", "disconnected");
+    __publicField(this, "statusListeners", /* @__PURE__ */ new Set());
+    __publicField(this, "logListeners", /* @__PURE__ */ new Set());
+    __publicField(this, "topicsListeners", /* @__PURE__ */ new Set());
+    __publicField(this, "servicesListeners", /* @__PURE__ */ new Set());
+    __publicField(this, "availableServices", []);
+    __publicField(this, "servicesPollTimer", null);
+    __publicField(this, "activeSubscriptions", /* @__PURE__ */ new Map());
+    __publicField(this, "breakerListeners", /* @__PURE__ */ new Map());
+    __publicField(this, "advertisedTopics", /* @__PURE__ */ new Set());
+    __publicField(this, "hasPublishedTwist", false);
+    __publicField(this, "controlOutbox", []);
+    __publicField(this, "controlFlushScheduled", false);
+    __publicField(this, "discoveredTopics", []);
+    __publicField(this, "pendingServiceCalls", /* @__PURE__ */ new Map());
+    __publicField(this, "serviceCallCounter", 0);
+    __publicField(this, "latencyProbeTimer", null);
+    __publicField(this, "reconnectAttempts", 0);
+    __publicField(this, "reconnectTimer", null);
+    __publicField(this, "connectionTimeoutTimer", null);
+    __publicField(this, "intentionalDisconnect", false);
+    this.onLatency = options?.onLatency;
+    this.logger = options?.logger ?? NOOP_LOGGER2;
+    this.getThrottleMode = options?.getThrottleMode ?? (() => "auto");
+    this.presets = buildEffectivePresets(options?.presetOverrides, this.logger);
+    setModeGetter(this.getThrottleMode);
+  }
+  get isConnected() {
+    return this.status === "connected";
+  }
+  get reconnectAttempt() {
+    return this.reconnectAttempts;
+  }
+  get maxReconnectAttempts() {
+    return MAX_RECONNECT_ATTEMPTS2;
+  }
+  async connect(url) {
+    if (this.status === "connecting" || this.status === "connected") {
+      return;
+    }
+    this.url = url.trim();
+    this.intentionalDisconnect = false;
+    this.reconnectAttempts = 0;
+    this.log(`Connecting to rosbridge at ${this.url}...`);
+    return this.performConnect();
+  }
+  async disconnect() {
+    this.intentionalDisconnect = true;
+    this.safePublishZeroTwist();
+    this.flushControlOutbox();
+    this.cleanup();
+    this.setStatus("disconnected");
+  }
+  async getAvailableTopics() {
+    if (!this.ws || !this.isConnected) {
+      return this.discoveredTopics;
+    }
+    try {
+      const result = await this.callService("/rosapi/topics", {});
+      const names = result.topics ?? [];
+      const types = result.types ?? [];
+      const topics = [];
+      for (let i = 0; i < names.length; i++) {
+        const name = names[i];
+        if (!name) continue;
+        topics.push({
+          topic: name,
+          schemaName: types[i] ?? "",
+          encoding: "json",
+          source: this.advertisedTopics.has(name) ? "app" : "robot"
+        });
+      }
+      this.discoveredTopics = topics;
+      this.log(`Discovered ${topics.length} topics.`);
+      this.notifyTopicsChanged();
+      return topics;
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      this.log(`Failed to get topics via rosapi: ${msg}`);
+      return this.discoveredTopics;
+    }
+  }
+  getSchemaTemplate(_schemaName) {
+    return null;
+  }
+  subscribe(topic, onMessage, options) {
+    if (!this.ws || this.status !== "connected") {
+      return () => {
+      };
+    }
+    const userMinIntervalMs = options?.maxFrequency && options.maxFrequency > 0 ? 1e3 / options.maxFrequency : void 0;
+    const disableAdaptive = options?.disableAdaptive ?? false;
+    const existing = this.activeSubscriptions.get(topic);
+    if (existing) {
+      existing.callbacks.set(onMessage, {
+        userMinIntervalMs,
+        disableAdaptive,
+        lastDeliveredAt: 0
+      });
+      return () => {
+        existing.callbacks.delete(onMessage);
+        if (existing.callbacks.size === 0) {
+          this.unsubscribeTopic(topic);
+        }
+      };
+    }
+    const topicInfo = this.discoveredTopics.find((t) => t.topic === topic);
+    const messageType = topicInfo?.schemaName ?? "";
+    if (!messageType) {
+      this.log(`Warning: subscribing to "${topic}" without known message type`);
+    }
+    const callbacks = /* @__PURE__ */ new Map();
+    callbacks.set(onMessage, {
+      userMinIntervalMs,
+      disableAdaptive,
+      lastDeliveredAt: 0
+    });
+    const breaker = new CircuitBreaker({
+      ...DEFAULT_BREAKER_CONFIG,
+      onStateChange: (newState) => {
+        const sub = this.activeSubscriptions.get(topic);
+        if (!sub) return;
+        sub.isPaused = newState === "tripped_auto" || newState === "tripped_manual";
+        if (newState === "tripped_auto") {
+          if (this.ws && this.status === "connected") {
+            this.send({ op: "unsubscribe", topic });
+          }
+          this.log(`[breaker] ${topic} \u2192 tripped_auto (sustained overload)`);
+        } else if (newState === "half_open") {
+          setTrackerToDeepest(sub.bandwidth, this.getThrottleMode());
+          if (this.ws && this.status === "connected") {
+            this.send({
+              op: "subscribe",
+              topic,
+              type: sub.schemaName,
+              throttle_rate: DEFAULT_THROTTLE_RATE_MS,
+              queue_length: 1
+            });
+          }
+          this.log(`[breaker] ${topic} \u2192 half_open (re-subscribed)`);
+        } else if (newState === "closed") {
+          this.log(`[breaker] ${topic} \u2192 closed (recovered)`);
+        } else if (newState === "tripped_manual") {
+          this.log(`[breaker] ${topic} \u2192 tripped_manual (user disabled auto-retry)`);
+        }
+        const listeners = this.breakerListeners.get(topic);
+        if (listeners) {
+          for (const cb of listeners) {
+            try {
+              cb(newState);
+            } catch (err) {
+              this.logger.error("[RosbridgeClient] Breaker listener error:", err);
+            }
+          }
+        }
+      }
+    });
+    this.activeSubscriptions.set(topic, {
+      schemaName: messageType,
+      callbacks,
+      bandwidth: createBandwidthTracker(this.getThrottleMode(), this.presets),
+      breaker,
+      isPaused: false
+    });
+    this.send({
+      op: "subscribe",
+      topic,
+      type: messageType,
+      throttle_rate: DEFAULT_THROTTLE_RATE_MS,
+      queue_length: 1
+    });
+    return () => {
+      callbacks.delete(onMessage);
+      if (callbacks.size === 0) {
+        this.unsubscribeTopic(topic);
+      }
+    };
+  }
+  publish(topic, schemaName, data, options) {
+    if (!this.ws || this.status !== "connected") {
+      return;
+    }
+    if (schemaName === CMD_VEL_SCHEMA2) {
+      this.hasPublishedTwist = true;
+    }
+    if (!this.advertisedTopics.has(topic)) {
+      this.send({
+        op: "advertise",
+        topic,
+        type: schemaName
+      });
+      this.advertisedTopics.add(topic);
+    }
+    const payload = { op: "publish", topic, msg: data };
+    if (options?.priority === "control") {
+      this.controlOutbox.push(payload);
+      this.scheduleControlFlush();
+      return;
+    }
+    this.send(payload);
+  }
+  scheduleControlFlush() {
+    if (this.controlFlushScheduled) return;
+    this.controlFlushScheduled = true;
+    setTimeout(() => {
+      this.controlFlushScheduled = false;
+      this.flushControlOutbox();
+    }, 0);
+  }
+  flushControlOutbox() {
+    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+      this.controlOutbox.length = 0;
+      return;
+    }
+    let drained = 0;
+    while (this.controlOutbox.length > 0 && drained < _RosbridgeClient.CONTROL_FLUSH_BATCH) {
+      const entry = this.controlOutbox.shift();
+      if (!entry) break;
+      this.send(entry);
+      drained++;
+    }
+    if (this.controlOutbox.length > 0) {
+      this.scheduleControlFlush();
+    }
+  }
+  ensureAdvertised(topic, schemaName) {
+    if (!this.ws || this.status !== "connected") return;
+    if (this.advertisedTopics.has(topic)) return;
+    this.send({
+      op: "advertise",
+      topic,
+      type: schemaName
+    });
+    this.advertisedTopics.add(topic);
+  }
+  unadvertise(topic) {
+    if (!this.advertisedTopics.has(topic)) return;
+    this.advertisedTopics.delete(topic);
+    if (this.ws && this.status === "connected") {
+      this.send({
+        op: "unadvertise",
+        topic
+      });
+    }
+  }
+  async callService(service, request) {
+    if (!this.ws || this.status !== "connected") {
+      throw new Error("Not connected");
+    }
+    const id = `service_call:${service}:${++this.serviceCallCounter}`;
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.pendingServiceCalls.delete(id);
+        reject(
+          new Error(`Service call "${service}" timed out after ${SERVICE_CALL_TIMEOUT_MS}ms`)
+        );
+      }, SERVICE_CALL_TIMEOUT_MS);
+      this.pendingServiceCalls.set(id, { resolve, reject, timer });
+      this.send({
+        op: "call_service",
+        id,
+        service,
+        args: request
+      });
+    });
+  }
+  onStatusChange(cb) {
+    this.statusListeners.add(cb);
+    cb(this.status);
+    return () => {
+      this.statusListeners.delete(cb);
+    };
+  }
+  onTopicsChange(cb) {
+    this.topicsListeners.add(cb);
+    return () => {
+      this.topicsListeners.delete(cb);
+    };
+  }
+  getAvailableServices() {
+    return [...this.availableServices];
+  }
+  onServicesChange(cb) {
+    this.servicesListeners.add(cb);
+    cb(this.getAvailableServices());
+    return () => {
+      this.servicesListeners.delete(cb);
+    };
+  }
+  async discoverServices() {
+    if (!this.isConnected) return;
+    try {
+      const result = await this.callService("/rosapi/services", {});
+      const names = result.services ?? [];
+      const next = names.map((n) => ({ name: n, type: "" }));
+      const prevKey = this.availableServices.map((s) => s.name).sort().join("|");
+      const nextKey = next.map((s) => s.name).sort().join("|");
+      if (prevKey === nextKey) return;
+      this.availableServices = next;
+      this.notifyServicesChanged();
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      this.log(`Service discovery via /rosapi/services failed: ${msg}`);
+      this.stopServicesPoll();
+    }
+  }
+  startServicesPoll() {
+    if (this.servicesPollTimer) return;
+    void this.discoverServices();
+    this.servicesPollTimer = setInterval(() => {
+      void this.discoverServices();
+    }, 3e4);
+  }
+  stopServicesPoll() {
+    if (this.servicesPollTimer) {
+      clearInterval(this.servicesPollTimer);
+      this.servicesPollTimer = null;
+    }
+  }
+  notifyServicesChanged() {
+    const snapshot = this.getAvailableServices();
+    for (const cb of this.servicesListeners) {
+      try {
+        cb(snapshot);
+      } catch (err) {
+        this.logger.error("[RosbridgeClient] Services listener error:", err);
+      }
+    }
+  }
+  onLog(cb) {
+    this.logListeners.add(cb);
+    return () => {
+      this.logListeners.delete(cb);
+    };
+  }
+  publishZeroTwist() {
+    this.safePublishZeroTwist();
+  }
+  // ── Private: connection lifecycle ──────────────────────────────────────
+  performConnect() {
+    this.cleanupConnection();
+    this.setStatus("connecting");
+    return new Promise((resolve, reject) => {
+      try {
+        this.ws = new WebSocket(this.url);
+        this.connectionTimeoutTimer = setTimeout(() => {
+          this.log(`Connection timeout after ${CONNECTION_TIMEOUT_MS2}ms`);
+          reject(new Error(`Connection timeout after ${CONNECTION_TIMEOUT_MS2}ms`));
+          this.cleanup();
+          this.setStatus("error");
+          this.scheduleReconnect();
+        }, CONNECTION_TIMEOUT_MS2);
+        this.ws.onopen = () => {
+          this.clearConnectionTimeout();
+          this.reconnectAttempts = 0;
+          this.log("Connected to rosbridge server.");
+          this.setStatus("connected");
+          this.startLatencyProbe();
+          this.startServicesPoll();
+          resolve();
+        };
+        this.ws.onerror = (event) => {
+          const detail = event.message ?? "Connection error";
+          this.log(`Rosbridge error: ${detail}`);
+          this.logger.error("[RosbridgeClient] Error:", event);
+          if (this.status === "connecting") {
+            this.clearConnectionTimeout();
+            reject(new Error(`Rosbridge error: ${detail}`));
+            this.cleanup();
+            this.setStatus("error");
+            this.scheduleReconnect();
+          }
+        };
+        this.ws.onclose = () => {
+          const wasConnected = this.status === "connected";
+          this.log("Rosbridge connection closed.");
+          if (wasConnected && this.hasPublishedTwist && !this.intentionalDisconnect) {
+            this.safePublishZeroTwist();
+          }
+          this.cleanupConnection();
+          this.setStatus("disconnected");
+          if (wasConnected && !this.intentionalDisconnect) {
+            this.scheduleReconnect();
+          }
+        };
+        this.ws.onmessage = (event) => {
+          this.handleMessage(event.data);
+        };
+      } catch (err) {
+        this.clearConnectionTimeout();
+        const error = err instanceof Error ? err : new Error(String(err));
+        reject(error);
+        this.cleanup();
+        this.setStatus("error");
+      }
+    });
+  }
+  // ── Private: message handling ──────────────────────────────────────────
+  handleMessage(raw) {
+    if (this.controlOutbox.length > 0) {
+      this.flushControlOutbox();
+    }
+    try {
+      const data = typeof raw === "string" ? raw : TEXT_DECODER2.decode(raw);
+      const byteSize = typeof raw === "string" ? data.length : raw.byteLength;
+      const mode = this.getThrottleMode();
+      if (this.tryDropPublishBeforeParse(data, byteSize, mode)) {
+        return;
+      }
+      const msg = JSON.parse(data);
+      const op = msg.op;
+      switch (op) {
+        case "publish":
+          this.handlePublish(msg, byteSize, mode);
+          break;
+        case "service_response":
+          this.handleServiceResponse(msg);
+          break;
+        case "status": {
+          const level = msg.level;
+          const statusMsg = msg.msg;
+          if (level === "error" || level === "warning") {
+            this.log(`rosbridge ${level}: ${statusMsg ?? "unknown"}`);
+          }
+          break;
+        }
+      }
+    } catch (err) {
+      this.logger.error("[RosbridgeClient] Failed to parse message:", err);
+    }
+  }
+  /**
+   * Drop a publish message before paying full `JSON.parse` cost.
+   *
+   * Rosbridge frames look like `{"op":"publish","topic":"…","msg":{…}}`.
+   * For fat payloads (base64-encoded camera frames, large arrays)
+   * `JSON.parse` on the whole envelope dominates per-message cost. We do a
+   * cheap substring search to extract `op` and `topic`, run the same
+   * throttle/breaker accounting `handlePublish` would do, and return `true`
+   * to skip the parse when no callback wants the message right now.
+   *
+   * Handles both compact (`{"op":"publish"`) and pretty (`{"op": "publish"`)
+   * JSON forms.
+   */
+  tryDropPublishBeforeParse(data, byteSize, mode) {
+    if (!data.startsWith('{"op":"publish"') && !data.startsWith('{"op": "publish"')) {
+      return false;
+    }
+    const topicKeyIdx = data.indexOf('"topic"');
+    if (topicKeyIdx < 0 || topicKeyIdx > 200) return false;
+    let i = topicKeyIdx + 7;
+    if (data[i] !== ":") return false;
+    i++;
+    if (data[i] === " ") i++;
+    if (data[i] !== '"') return false;
+    i++;
+    const topicEnd = data.indexOf('"', i);
+    if (topicEnd < 0) return false;
+    const topic = data.slice(i, topicEnd);
+    const sub = this.activeSubscriptions.get(topic);
+    if (!sub) return true;
+    const now = Date.now();
+    if (sub.isPaused) {
+      recordBytes(sub.bandwidth, now, byteSize, mode);
+      return true;
+    }
+    let anyCallbackWantsThis = false;
+    for (const entry of sub.callbacks.values()) {
+      const interval = effectiveMinInterval(
+        entry.userMinIntervalMs,
+        entry.disableAdaptive,
+        sub.bandwidth
+      );
+      if (interval <= 0 || now - entry.lastDeliveredAt >= interval) {
+        anyCallbackWantsThis = true;
+        break;
+      }
+    }
+    if (anyCallbackWantsThis) return false;
+    recordBytes(sub.bandwidth, now, byteSize, mode);
+    sub.breaker.recordObservation(now, sub.bandwidth.bytesPerSec, getMaxLagMs());
+    return true;
+  }
+  handlePublish(msg, byteSize, mode) {
+    const topic = msg.topic;
+    const msgData = msg.msg ?? {};
+    const sub = this.activeSubscriptions.get(topic);
+    if (!sub) return;
+    if (sub.isPaused) return;
+    const now = Date.now();
+    recordBytes(sub.bandwidth, now, byteSize, mode);
+    sub.breaker.recordObservation(now, sub.bandwidth.bytesPerSec, getMaxLagMs());
+    const deliverTo = [];
+    for (const [cb, entry] of sub.callbacks) {
+      const interval = effectiveMinInterval(
+        entry.userMinIntervalMs,
+        entry.disableAdaptive,
+        sub.bandwidth
+      );
+      if (interval <= 0 || now - entry.lastDeliveredAt >= interval) {
+        deliverTo.push([cb, entry]);
+      }
+    }
+    if (deliverTo.length === 0) return;
+    const rosMsg = {
+      topic,
+      schemaName: sub.schemaName,
+      encoding: "json",
+      data: msgData,
+      receiveTime: {
+        sec: Math.floor(now / 1e3),
+        nsec: now % 1e3 * 1e6
+      },
+      byteSize
+    };
+    for (const [cb, entry] of deliverTo) {
+      entry.lastDeliveredAt = now;
+      try {
+        cb(rosMsg);
+      } catch (err) {
+        this.logger.error("[RosbridgeClient] Subscriber callback error:", err);
+      }
+    }
+  }
+  handleServiceResponse(msg) {
+    const id = msg.id;
+    const pending = this.pendingServiceCalls.get(id);
+    if (!pending) return;
+    clearTimeout(pending.timer);
+    this.pendingServiceCalls.delete(id);
+    const success = msg.result === true || msg.result === "true";
+    if (success) {
+      const values = msg.values ?? {};
+      pending.resolve(values);
+    } else {
+      const errorMsg = typeof msg.values === "string" ? msg.values : "Service call failed";
+      pending.reject(new Error(errorMsg));
+    }
+  }
+  // ── Private: topic management ──────────────────────────────────────────
+  unsubscribeTopic(topic) {
+    const sub = this.activeSubscriptions.get(topic);
+    sub?.breaker.destroy();
+    this.activeSubscriptions.delete(topic);
+    if (this.ws && this.status === "connected" && !sub?.isPaused) {
+      this.send({ op: "unsubscribe", topic });
+    }
+  }
+  // ── IProtocolClient: circuit breaker controls ─────────────────────────────
+  getBreakerState(topic) {
+    return this.activeSubscriptions.get(topic)?.breaker.getState() ?? "closed";
+  }
+  getBreakerNextRetryAt(topic) {
+    return this.activeSubscriptions.get(topic)?.breaker.getNextRetryAt() ?? null;
+  }
+  getSubscriptionStats(topic) {
+    const sub = this.activeSubscriptions.get(topic);
+    if (!sub) return null;
+    const mode = this.getThrottleMode();
+    return {
+      adaptiveMinIntervalMs: sub.bandwidth.adaptiveMinIntervalMs,
+      bucketLabel: getTrackerBucketLabel(sub.bandwidth, mode),
+      bytesPerSec: sub.bandwidth.bytesPerSec
+    };
+  }
+  breakerRetry(topic) {
+    this.activeSubscriptions.get(topic)?.breaker.retry();
+  }
+  breakerDisable(topic) {
+    this.activeSubscriptions.get(topic)?.breaker.disable();
+  }
+  onBreakerStateChange(topic, cb) {
+    let listeners = this.breakerListeners.get(topic);
+    if (!listeners) {
+      listeners = /* @__PURE__ */ new Set();
+      this.breakerListeners.set(topic, listeners);
+    }
+    listeners.add(cb);
+    return () => {
+      const set = this.breakerListeners.get(topic);
+      if (set) {
+        set.delete(cb);
+        if (set.size === 0) this.breakerListeners.delete(topic);
+      }
+    };
+  }
+  // ── Private: dead-man's switch ─────────────────────────────────────────
+  safePublishZeroTwist() {
+    if (!this.hasPublishedTwist) return;
+    try {
+      if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+        this.publish("/cmd_vel", CMD_VEL_SCHEMA2, ZERO_TWIST2, { priority: "control" });
+      }
+    } catch {
+    }
+    this.hasPublishedTwist = false;
+  }
+  // ── Private: latency probe ──────────────────────────────────────────────
+  startLatencyProbe() {
+    this.stopLatencyProbe();
+    this.latencyProbeTimer = setInterval(() => {
+      if (!this.ws || this.status !== "connected") return;
+      const start = Date.now();
+      const id = `latency_probe:${++this.serviceCallCounter}`;
+      const timer = setTimeout(() => {
+        this.pendingServiceCalls.delete(id);
+      }, 5e3);
+      this.pendingServiceCalls.set(id, {
+        resolve: () => {
+          clearTimeout(timer);
+          if (this.onLatency) {
+            try {
+              this.onLatency(Date.now() - start);
+            } catch {
+            }
+          }
+        },
+        reject: () => {
+          clearTimeout(timer);
+        },
+        timer
+      });
+      this.send({
+        op: "call_service",
+        id,
+        service: "/rosapi/topics",
+        args: {}
+      });
+    }, 5e3);
+  }
+  stopLatencyProbe() {
+    if (this.latencyProbeTimer) {
+      clearInterval(this.latencyProbeTimer);
+      this.latencyProbeTimer = null;
+    }
+  }
+  // ── Private: reconnection ──────────────────────────────────────────────
+  scheduleReconnect() {
+    if (this.intentionalDisconnect || this.reconnectTimer !== null || this.reconnectAttempts >= MAX_RECONNECT_ATTEMPTS2) {
+      if (this.reconnectAttempts >= MAX_RECONNECT_ATTEMPTS2) {
+        this.log(`Max reconnect attempts (${MAX_RECONNECT_ATTEMPTS2}) reached.`);
+        this.setStatus("error");
+      }
+      return;
+    }
+    const delay = Math.min(
+      BASE_RECONNECT_DELAY_MS2 * Math.pow(2, this.reconnectAttempts),
+      16e3
+    );
+    this.log(
+      `Scheduling reconnect attempt ${this.reconnectAttempts + 1}/${MAX_RECONNECT_ATTEMPTS2} in ${delay}ms...`
+    );
+    this.reconnectAttempts++;
+    this.reconnectTimer = setTimeout(() => {
+      this.reconnectTimer = null;
+      this.performConnect().catch((err) => {
+        this.logger.error("[RosbridgeClient] Reconnect failed:", err);
+      });
+    }, delay);
+  }
+  // ── Private: cleanup ───────────────────────────────────────────────────
+  cleanupConnection() {
+    this.clearConnectionTimeout();
+    this.stopServicesPoll();
+    this.activeSubscriptions.clear();
+    for (const [, pending] of this.pendingServiceCalls) {
+      clearTimeout(pending.timer);
+      pending.reject(new Error("Connection closed"));
+    }
+    this.pendingServiceCalls.clear();
+    if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+      for (const topic of this.advertisedTopics) {
+        try {
+          this.send({ op: "unadvertise", topic });
+        } catch {
+        }
+      }
+    }
+    this.advertisedTopics.clear();
+  }
+  cleanup() {
+    this.cleanupConnection();
+    this.stopLatencyProbe();
+    this.stopServicesPoll();
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+    if (this.ws) {
+      try {
+        this.ws.close();
+      } catch {
+      }
+      this.ws = null;
+    }
+    this.discoveredTopics = [];
+    if (this.availableServices.length > 0) {
+      this.availableServices = [];
+      this.notifyServicesChanged();
+    }
+  }
+  clearConnectionTimeout() {
+    if (this.connectionTimeoutTimer) {
+      clearTimeout(this.connectionTimeoutTimer);
+      this.connectionTimeoutTimer = null;
+    }
+  }
+  // ── Private: helpers ───────────────────────────────────────────────────
+  send(msg) {
+    if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+      this.ws.send(JSON.stringify(msg));
+    }
+  }
+  setStatus(status) {
+    if (this.status === status) return;
+    this.status = status;
+    for (const cb of this.statusListeners) {
+      try {
+        cb(status);
+      } catch (err) {
+        this.logger.error("[RosbridgeClient] Status listener error:", err);
+      }
+    }
+  }
+  notifyTopicsChanged() {
+    for (const cb of this.topicsListeners) {
+      try {
+        cb(this.discoveredTopics);
+      } catch (err) {
+        this.logger.error("[RosbridgeClient] Topics listener error:", err);
+      }
+    }
+  }
+  log(message) {
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString().substring(11, 23);
+    const formatted = `[${timestamp}] ${message}`;
+    this.logger.log(`[RosbridgeClient] ${formatted}`);
+    for (const cb of this.logListeners) {
+      try {
+        cb(formatted);
+      } catch (err) {
+        this.logger.error("[RosbridgeClient] Log listener error:", err);
+      }
+    }
+  }
+};
+__publicField(_RosbridgeClient, "CONTROL_FLUSH_BATCH", 3);
+var RosbridgeClient = _RosbridgeClient;
+
+// src/constants.ts
+var DEFAULT_PORTS = {
+  "foxglove-ws": 8765,
+  rosbridge: 9090,
+  zenoh: 7447
+};
+
+// src/ProtocolManager.ts
+function sanitizeHost(raw) {
+  let host = (raw ?? "").trim();
+  host = host.replace(/^(wss?|https?):\/\//i, "");
+  host = host.split("/")[0] ?? host;
+  host = host.split("?")[0] ?? host;
+  host = host.split("#")[0] ?? host;
+  if (!host.startsWith("[")) {
+    const colonIx = host.indexOf(":");
+    if (colonIx !== -1) host = host.slice(0, colonIx);
+  }
+  return host;
+}
+var ProtocolManager = class {
+  constructor() {
+    __publicField(this, "activeClient", null);
+    __publicField(this, "activeOptions", null);
+    __publicField(this, "clientOptions");
+  }
+  /**
+   * Set options forwarded to every client constructed by this manager.
+   * Host applications typically call this once at startup.
+   */
+  setClientOptions(options) {
+    this.clientOptions = options;
+  }
+  /**
+   * Create and connect a protocol client for the given options.
+   *
+   * For `protocol: 'zenoh'`, throws a clear "planned for v0.2.0" error —
+   * the v0.1.0 release does not ship a Zenoh implementation.
+   */
+  async connect(options) {
+    if (this.activeClient) {
+      await this.activeClient.disconnect();
+    }
+    const client = this.createClient(options);
+    const scheme = options.secure ? "wss" : "ws";
+    const port = options.port || DEFAULT_PORTS[options.protocol];
+    const host = sanitizeHost(options.host);
+    const url = `${scheme}://${host}:${port}`;
+    try {
+      new URL(url);
+    } catch {
+      throw new Error(
+        `Invalid connection URL "${url}" \u2014 check host and port. Hosts should not include "ws://" or ":port"; use the port field instead.`
+      );
+    }
+    await client.connect(url);
+    this.activeClient = client;
+    this.activeOptions = options;
+    return client;
+  }
+  /**
+   * Disconnect the active client and forget it.
+   */
+  async disconnect() {
+    if (this.activeClient) {
+      await this.activeClient.disconnect();
+      this.activeClient = null;
+      this.activeOptions = null;
+    }
+  }
+  /**
+   * Currently active client, or `null` if not connected.
+   */
+  getClient() {
+    return this.activeClient;
+  }
+  /**
+   * Currently active connection options, or `null` if not connected.
+   */
+  getOptions() {
+    return this.activeOptions;
+  }
+  createClient(options) {
+    switch (options.protocol) {
+      case "foxglove-ws":
+        return new FoxgloveClient(this.clientOptions);
+      case "rosbridge":
+        return new RosbridgeClient(this.clientOptions);
+      case "zenoh":
+        throw new Error("Zenoh support is planned for v0.2.0");
+      default: {
+        const exhaustive = options.protocol;
+        throw new Error(`Unknown protocol: ${String(exhaustive)}`);
+      }
+    }
+  }
+};
+
+exports.DEFAULT_PORTS = DEFAULT_PORTS;
+exports.DEFAULT_PRESETS = DEFAULT_PRESETS;
+exports.FoxgloveClient = FoxgloveClient;
+exports.ProtocolManager = ProtocolManager;
+exports.RosbridgeClient = RosbridgeClient;
+exports.bucketLabelForLag = bucketLabelForLag;
+exports.clearLagHistory = clearLagHistory;
+exports.getLagHistoryCsv = getLagHistoryCsv;
+exports.getLagStats = getLagStats;
+exports.getMaxLagMs = getMaxLagMs;
+exports.jsonSchemaToTemplate = jsonSchemaToTemplate;
+exports.schemaToTemplate = schemaToTemplate;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map