ros-mobile-bridge 0.1.2 → 0.1.4

package/dist/index.cjs

@@ -478,6 +478,16 @@ function jsonSchemaToTemplate(schema) {
   return null;
 }
 
+// src/schemaName.ts
+var INTERFACE_KIND = /^([^/]+)\/(?:msg|srv|action)\/([^/]+)$/;
+function stripInterfaceKind(name) {
+  const m = INTERFACE_KIND.exec(name);
+  return m ? `${m[1]}/${m[2]}` : name;
+}
+function matchesSchema(a, b) {
+  return stripInterfaceKind(a) === stripInterfaceKind(b);
+}
+
 // src/builtinSchemas.ts
 var SEP = "\n================================================================================\n";
 var MSG_PARAMETER_VALUE = `MSG: rcl_interfaces/ParameterValue
@@ -581,7 +591,13 @@ var BUNDLED = {
   }
 };
 function getBundledServiceSchema(serviceType) {
-  return BUNDLED[serviceType] ?? null;
+  const exact = BUNDLED[serviceType];
+  if (exact) return exact;
+  const target = stripInterfaceKind(serviceType);
+  for (const key of Object.keys(BUNDLED)) {
+    if (stripInterfaceKind(key) === target) return BUNDLED[key] ?? null;
+  }
+  return null;
 }
 
 // src/FoxgloveClient.ts
@@ -591,13 +607,30 @@ var NOOP_LOGGER = { log() {
 } };
 var TEXT_ENCODER = new TextEncoder();
 var TEXT_DECODER = new TextDecoder();
+var B64_LOOKUP = (() => {
+  const table = new Int16Array(256).fill(-1);
+  const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+  for (let i = 0; i < chars.length; i++) table[chars.charCodeAt(i)] = i;
+  return table;
+})();
 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;
+  let len = b64.length;
+  while (len > 0 && b64.charCodeAt(len - 1) === 61) len--;
+  const out = new Uint8Array(len * 3 >> 2);
+  let acc = 0;
+  let bits = 0;
+  let o = 0;
+  for (let i = 0; i < len; i++) {
+    const v = B64_LOOKUP[b64.charCodeAt(i)] ?? -1;
+    if (v < 0) continue;
+    acc = acc << 6 | v;
+    bits += 6;
+    if (bits >= 8) {
+      bits -= 8;
+      out[o++] = acc >>> bits & 255;
+    }
+  }
+  return o === out.length ? out : out.subarray(0, o);
 }
 var CDR_LE_HEADER = new Uint8Array([0, 1, 0, 0]);
 function isEmptyRequest(request) {
@@ -789,6 +822,7 @@ var _FoxgloveClient = class _FoxgloveClient {
   subscribe(topic, onMessage, options) {
     const userMinIntervalMs = options?.maxFrequency && options.maxFrequency > 0 ? 1e3 / options.maxFrequency : void 0;
     const disableAdaptive = options?.disableAdaptive ?? false;
+    const dispatchMode = options?.dispatchMode ?? "immediate";
     const existingSubId = this.topicToSubscriptionId.get(topic);
     if (existingSubId !== void 0) {
       const sub = this.subscriptions.get(existingSubId);
@@ -796,9 +830,14 @@ var _FoxgloveClient = class _FoxgloveClient {
         sub.callbacks.set(onMessage, {
           userMinIntervalMs,
           disableAdaptive,
-          lastDeliveredAt: 0
+          lastDeliveredAt: 0,
+          dispatchMode,
+          pending: null,
+          drainTimer: null
         });
         return () => {
+          const entry = sub.callbacks.get(onMessage);
+          if (entry) this.cancelDrain(entry);
           sub.callbacks.delete(onMessage);
           if (sub.callbacks.size === 0) {
             this.unsubscribeTopic(topic, existingSubId);
@@ -819,7 +858,10 @@ var _FoxgloveClient = class _FoxgloveClient {
     callbacks.set(onMessage, {
       userMinIntervalMs,
       disableAdaptive,
-      lastDeliveredAt: 0
+      lastDeliveredAt: 0,
+      dispatchMode,
+      pending: null,
+      drainTimer: null
     });
     const breaker = new CircuitBreaker({
       ...DEFAULT_BREAKER_CONFIG,
@@ -827,6 +869,7 @@ var _FoxgloveClient = class _FoxgloveClient {
         const sub = this.subscriptions.get(subscriptionId);
         if (!sub) return;
         sub.isPaused = newState === "tripped_auto" || newState === "tripped_manual";
+        if (sub.isPaused) this.cancelAllDrains(sub);
         if (newState === "tripped_auto") {
           if (this.ws && this.status === "connected") {
             this.sendJson({ op: "unsubscribe", subscriptionIds: [subscriptionId] });
@@ -892,6 +935,8 @@ var _FoxgloveClient = class _FoxgloveClient {
       subscriptions: [{ id: subscriptionId, channelId }]
     });
     return () => {
+      const entry = callbacks.get(onMessage);
+      if (entry) this.cancelDrain(entry);
       callbacks.delete(onMessage);
       if (callbacks.size === 0) {
         this.unsubscribeTopic(topic, subscriptionId);
@@ -1184,7 +1229,6 @@ var _FoxgloveClient = class _FoxgloveClient {
           this.log(
             `WebSocket handshake successful (protocol: ${negotiated}), waiting for serverInfo...`
           );
-          this.clearConnectionTimeout();
         };
         this.ws.onmessage = (event) => {
           this.handleWsMessage(event);
@@ -1214,10 +1258,14 @@ var _FoxgloveClient = class _FoxgloveClient {
     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);
+    try {
+      if (typeof event.data === "string") {
+        this.handleJsonMessage(event.data);
+      } else if (event.data instanceof ArrayBuffer) {
+        this.handleBinaryMessage(event.data);
+      }
+    } catch (err) {
+      this.logger.error("[FoxgloveClient] Error handling inbound message:", err);
     }
   }
   handleJsonMessage(raw) {
@@ -1306,52 +1354,110 @@ var _FoxgloveClient = class _FoxgloveClient {
       }
     }
     if (deliverTo.length === 0) return;
-    const channelInfo = this.channels.get(sub.channelId);
-    const schemaName = channelInfo?.schemaName ?? "";
-    const encoding = channelInfo?.encoding ?? "json";
-    let data;
+    let parsed = null;
+    for (const [cb, entry] of deliverTo) {
+      entry.lastDeliveredAt = now;
+      if (entry.dispatchMode === "latest-only") {
+        entry.pending = { payload: new Uint8Array(payload), sec, nsec };
+        if (entry.drainTimer === null) {
+          entry.drainTimer = setTimeout(
+            () => this.drainLatestOnly(subscriptionId, cb, entry),
+            0
+          );
+        }
+        continue;
+      }
+      if (parsed === null) {
+        const channelInfo = this.channels.get(sub.channelId);
+        const encoding = channelInfo?.encoding ?? "json";
+        parsed = {
+          topic: sub.topic,
+          schemaName: channelInfo?.schemaName ?? "",
+          encoding: encoding === "json" ? "json" : "cdr",
+          data: this.decodePayload(payload, subscriptionId, encoding),
+          receiveTime: { sec, nsec },
+          byteSize: payload.byteLength
+        };
+      }
+      try {
+        cb(parsed);
+      } catch (err) {
+        this.logger.error("[FoxgloveClient] Subscriber callback error:", err);
+      }
+    }
+  }
+  /**
+   * Decode a `messageData` payload to its delivered shape: a parsed object when
+   * a CDR reader or JSON decode succeeds, the raw bytes otherwise. Shared by
+   * the synchronous `immediate` path and the deferred `latest-only` drain.
+   */
+  decodePayload(payload, subscriptionId, encoding) {
     if (encoding === "json") {
       try {
-        const text = TEXT_DECODER.decode(payload);
-        data = JSON.parse(text);
+        return JSON.parse(TEXT_DECODER.decode(payload));
       } catch {
-        data = payload;
+        return payload;
       }
-    } else {
-      const reader = this.messageReaders.get(subscriptionId);
-      if (reader) {
-        try {
-          data = reader.readMessage(payload);
-        } catch {
-          data = payload;
-        }
-      } else {
-        data = payload;
+    }
+    const reader = this.messageReaders.get(subscriptionId);
+    if (reader) {
+      try {
+        return reader.readMessage(payload);
+      } catch {
+        return payload;
       }
     }
+    return payload;
+  }
+  /**
+   * Drain one `latest-only` callback's pending payload: parse the survivor and
+   * deliver it. Cleared state (`pending`, `drainTimer`) is reset *before* the
+   * callback runs, so a throwing callback never wedges future delivery — the
+   * next arrival re-arms normally. Bails if the subscription was torn down or
+   * paused while the drain was armed (no post-teardown delivery).
+   */
+  drainLatestOnly(subscriptionId, cb, entry) {
+    entry.drainTimer = null;
+    const pending = entry.pending;
+    entry.pending = null;
+    if (!pending) return;
+    const sub = this.subscriptions.get(subscriptionId);
+    if (!sub || sub.isPaused) return;
+    const channelInfo = this.channels.get(sub.channelId);
+    const encoding = channelInfo?.encoding ?? "json";
     const rosMsg = {
       topic: sub.topic,
-      schemaName,
+      schemaName: channelInfo?.schemaName ?? "",
       encoding: encoding === "json" ? "json" : "cdr",
-      data,
-      receiveTime: { sec, nsec },
-      byteSize: payload.byteLength
+      data: this.decodePayload(pending.payload, subscriptionId, encoding),
+      receiveTime: { sec: pending.sec, nsec: pending.nsec },
+      byteSize: pending.payload.byteLength
     };
-    for (const [cb, entry] of deliverTo) {
-      entry.lastDeliveredAt = now;
-      try {
-        cb(rosMsg);
-      } catch (err) {
-        this.logger.error("[FoxgloveClient] Subscriber callback error:", err);
-      }
+    try {
+      cb(rosMsg);
+    } catch (err) {
+      this.logger.error("[FoxgloveClient] Subscriber callback error:", err);
+    }
+  }
+  /** Cancel one callback's armed drain and drop its pending payload. */
+  cancelDrain(entry) {
+    if (entry.drainTimer !== null) {
+      clearTimeout(entry.drainTimer);
+      entry.drainTimer = null;
     }
+    entry.pending = null;
+  }
+  /** Cancel every armed drain on a subscription (teardown / pause). */
+  cancelAllDrains(sub) {
+    for (const entry of sub.callbacks.values()) this.cancelDrain(entry);
   }
   handleServerInfo(info) {
     this.log(`Received serverInfo: ${info.name} (sessionId: ${info.sessionId ?? "none"})`);
     this.serverInfoReceived = true;
   }
   handleAdvertise(msg) {
-    for (const ch of msg.channels) {
+    const channels = Array.isArray(msg.channels) ? msg.channels : [];
+    for (const ch of channels) {
       this.channels.set(ch.id, ch);
       this.topicToChannelId.set(ch.topic, ch.id);
       this.log(
@@ -1359,7 +1465,7 @@ var _FoxgloveClient = class _FoxgloveClient {
       );
     }
     if (this.connectResolve && this.serverInfoReceived) {
-      this.log(`Connection established with ${msg.channels.length} initial topics.`);
+      this.log(`Connection established with ${channels.length} initial topics.`);
       this.clearConnectionTimeout();
       this.reconnectAttempts = 0;
       this.setStatus("connected");
@@ -1371,7 +1477,8 @@ var _FoxgloveClient = class _FoxgloveClient {
     }
   }
   handleUnadvertise(msg) {
-    for (const id of msg.channelIds) {
+    const channelIds = Array.isArray(msg.channelIds) ? msg.channelIds : [];
+    for (const id of channelIds) {
       const ch = this.channels.get(id);
       if (ch) {
         this.topicToChannelId.delete(ch.topic);
@@ -1381,7 +1488,8 @@ var _FoxgloveClient = class _FoxgloveClient {
     this.notifyTopicsChanged();
   }
   handleAdvertiseServices(msg) {
-    for (const svc of msg.services) {
+    const services = Array.isArray(msg.services) ? msg.services : [];
+    for (const svc of services) {
       this.availableServices.set(svc.name, svc);
     }
     this.notifyServicesChanged();
@@ -1505,6 +1613,8 @@ var _FoxgloveClient = class _FoxgloveClient {
   // ── Private: reconnection ────────────────────────────────────────────────
   handleConnectionError(error) {
     this.clearConnectionTimeout();
+    const wasConnected = this.status === "connected";
+    const reconnecting = this.reconnectAttempts > 0;
     if (this.connectReject) {
       this.connectReject(error);
       this.connectResolve = null;
@@ -1512,10 +1622,17 @@ var _FoxgloveClient = class _FoxgloveClient {
     }
     this.setStatus("error");
     this.cleanup();
-    this.scheduleReconnect();
+    if (wasConnected || reconnecting) {
+      this.scheduleReconnect();
+    }
   }
   handleClose(_code, _reason) {
     const wasConnected = this.status === "connected";
+    if (this.connectReject) {
+      this.connectReject(new Error("Connection closed before the handshake completed"));
+      this.connectResolve = null;
+      this.connectReject = null;
+    }
     if (wasConnected && this.hasPublishedTwist && !this.intentionalDisconnect) {
       this.safePublishZeroTwist();
     }
@@ -1553,6 +1670,7 @@ var _FoxgloveClient = class _FoxgloveClient {
   // ── Private: unsubscribe ─────────────────────────────────────────────────
   unsubscribeTopic(topic, subscriptionId) {
     const sub = this.subscriptions.get(subscriptionId);
+    if (sub) this.cancelAllDrains(sub);
     sub?.breaker.destroy();
     this.subscriptions.delete(subscriptionId);
     this.topicToSubscriptionId.delete(topic);
@@ -1649,6 +1767,10 @@ var _FoxgloveClient = class _FoxgloveClient {
       }
       this.ws = null;
     }
+    for (const sub of this.subscriptions.values()) {
+      this.cancelAllDrains(sub);
+      sub.breaker.destroy();
+    }
     this.channels.clear();
     this.topicToChannelId.clear();
     this.subscriptions.clear();
@@ -1839,14 +1961,20 @@ var _RosbridgeClient = class _RosbridgeClient {
     }
     const userMinIntervalMs = options?.maxFrequency && options.maxFrequency > 0 ? 1e3 / options.maxFrequency : void 0;
     const disableAdaptive = options?.disableAdaptive ?? false;
+    const dispatchMode = options?.dispatchMode ?? "immediate";
     const existing = this.activeSubscriptions.get(topic);
     if (existing) {
       existing.callbacks.set(onMessage, {
         userMinIntervalMs,
         disableAdaptive,
-        lastDeliveredAt: 0
+        lastDeliveredAt: 0,
+        dispatchMode,
+        pending: null,
+        drainTimer: null
       });
       return () => {
+        const entry = existing.callbacks.get(onMessage);
+        if (entry) this.cancelDrain(entry);
         existing.callbacks.delete(onMessage);
         if (existing.callbacks.size === 0) {
           this.unsubscribeTopic(topic);
@@ -1862,7 +1990,10 @@ var _RosbridgeClient = class _RosbridgeClient {
     callbacks.set(onMessage, {
       userMinIntervalMs,
       disableAdaptive,
-      lastDeliveredAt: 0
+      lastDeliveredAt: 0,
+      dispatchMode,
+      pending: null,
+      drainTimer: null
     });
     const breaker = new CircuitBreaker({
       ...DEFAULT_BREAKER_CONFIG,
@@ -1870,6 +2001,7 @@ var _RosbridgeClient = class _RosbridgeClient {
         const sub = this.activeSubscriptions.get(topic);
         if (!sub) return;
         sub.isPaused = newState === "tripped_auto" || newState === "tripped_manual";
+        if (sub.isPaused) this.cancelAllDrains(sub);
         if (newState === "tripped_auto") {
           if (this.ws && this.status === "connected") {
             this.send({ op: "unsubscribe", topic });
@@ -1919,6 +2051,8 @@ var _RosbridgeClient = class _RosbridgeClient {
       queue_length: 1
     });
     return () => {
+      const entry = callbacks.get(onMessage);
+      if (entry) this.cancelDrain(entry);
       callbacks.delete(onMessage);
       if (callbacks.size === 0) {
         this.unsubscribeTopic(topic);
@@ -2099,10 +2233,11 @@ var _RosbridgeClient = class _RosbridgeClient {
         this.ws = new WebSocket(this.url);
         this.connectionTimeoutTimer = setTimeout(() => {
           this.log(`Connection timeout after ${CONNECTION_TIMEOUT_MS2}ms`);
+          const reconnecting = this.reconnectAttempts > 0;
           reject(new Error(`Connection timeout after ${CONNECTION_TIMEOUT_MS2}ms`));
           this.cleanup();
           this.setStatus("error");
-          this.scheduleReconnect();
+          if (reconnecting) this.scheduleReconnect();
         }, CONNECTION_TIMEOUT_MS2);
         this.ws.onopen = () => {
           this.clearConnectionTimeout();
@@ -2118,11 +2253,12 @@ var _RosbridgeClient = class _RosbridgeClient {
           this.log(`Rosbridge error: ${detail}`);
           this.logger.error("[RosbridgeClient] Error:", event);
           if (this.status === "connecting") {
+            const reconnecting = this.reconnectAttempts > 0;
             this.clearConnectionTimeout();
             reject(new Error(`Rosbridge error: ${detail}`));
             this.cleanup();
             this.setStatus("error");
-            this.scheduleReconnect();
+            if (reconnecting) this.scheduleReconnect();
           }
         };
         this.ws.onclose = () => {
@@ -2218,19 +2354,26 @@ var _RosbridgeClient = class _RosbridgeClient {
       recordBytes(sub.bandwidth, now, byteSize, mode);
       return true;
     }
-    let anyCallbackWantsThis = false;
-    for (const entry of sub.callbacks.values()) {
+    let anyImmediateWantsThis = false;
+    for (const [cb, entry] of sub.callbacks) {
       const interval = effectiveMinInterval(
         entry.userMinIntervalMs,
         entry.disableAdaptive,
         sub.bandwidth
       );
-      if (interval <= 0 || now - entry.lastDeliveredAt >= interval) {
-        anyCallbackWantsThis = true;
-        break;
+      const eligible = interval <= 0 || now - entry.lastDeliveredAt >= interval;
+      if (!eligible) continue;
+      if (entry.dispatchMode === "latest-only") {
+        entry.lastDeliveredAt = now;
+        entry.pending = { raw: data, receivedAt: now };
+        if (entry.drainTimer === null) {
+          entry.drainTimer = setTimeout(() => this.drainLatestOnly(topic, cb, entry), 0);
+        }
+      } else {
+        anyImmediateWantsThis = true;
       }
     }
-    if (anyCallbackWantsThis) return false;
+    if (anyImmediateWantsThis) return false;
     recordBytes(sub.bandwidth, now, byteSize, mode);
     sub.breaker.recordObservation(now, sub.bandwidth.bytesPerSec, getMaxLagMs());
     return true;
@@ -2246,6 +2389,7 @@ var _RosbridgeClient = class _RosbridgeClient {
     sub.breaker.recordObservation(now, sub.bandwidth.bytesPerSec, getMaxLagMs());
     const deliverTo = [];
     for (const [cb, entry] of sub.callbacks) {
+      if (entry.dispatchMode === "latest-only") continue;
       const interval = effectiveMinInterval(
         entry.userMinIntervalMs,
         entry.disableAdaptive,
@@ -2276,6 +2420,55 @@ var _RosbridgeClient = class _RosbridgeClient {
       }
     }
   }
+  /**
+   * Drain one `latest-only` callback's pending frame: parse the survivor and
+   * deliver it. State (`pending`, `drainTimer`) is cleared *before* the
+   * callback runs, so a throwing callback never wedges future delivery. Bails
+   * if the subscription was torn down or paused while the drain was armed (no
+   * post-teardown delivery).
+   */
+  drainLatestOnly(topic, cb, entry) {
+    entry.drainTimer = null;
+    const pending = entry.pending;
+    entry.pending = null;
+    if (!pending) return;
+    const sub = this.activeSubscriptions.get(topic);
+    if (!sub || sub.isPaused) return;
+    let parsed;
+    try {
+      parsed = JSON.parse(pending.raw);
+    } catch {
+      return;
+    }
+    const rosMsg = {
+      topic,
+      schemaName: sub.schemaName,
+      encoding: "json",
+      data: parsed.msg ?? {},
+      receiveTime: {
+        sec: Math.floor(pending.receivedAt / 1e3),
+        nsec: pending.receivedAt % 1e3 * 1e6
+      },
+      byteSize: pending.raw.length
+    };
+    try {
+      cb(rosMsg);
+    } catch (err) {
+      this.logger.error("[RosbridgeClient] Subscriber callback error:", err);
+    }
+  }
+  /** Cancel one callback's armed drain and drop its pending frame. */
+  cancelDrain(entry) {
+    if (entry.drainTimer !== null) {
+      clearTimeout(entry.drainTimer);
+      entry.drainTimer = null;
+    }
+    entry.pending = null;
+  }
+  /** Cancel every armed drain on a subscription (teardown / pause). */
+  cancelAllDrains(sub) {
+    for (const entry of sub.callbacks.values()) this.cancelDrain(entry);
+  }
   handleServiceResponse(msg) {
     const id = msg.id;
     const pending = this.pendingServiceCalls.get(id);
@@ -2294,6 +2487,7 @@ var _RosbridgeClient = class _RosbridgeClient {
   // ── Private: topic management ──────────────────────────────────────────
   unsubscribeTopic(topic) {
     const sub = this.activeSubscriptions.get(topic);
+    if (sub) this.cancelAllDrains(sub);
     sub?.breaker.destroy();
     this.activeSubscriptions.delete(topic);
     if (this.ws && this.status === "connected" && !sub?.isPaused) {
@@ -2416,6 +2610,10 @@ var _RosbridgeClient = class _RosbridgeClient {
   cleanupConnection() {
     this.clearConnectionTimeout();
     this.stopServicesPoll();
+    for (const sub of this.activeSubscriptions.values()) {
+      this.cancelAllDrains(sub);
+      sub.breaker.destroy();
+    }
     this.activeSubscriptions.clear();
     for (const [, pending] of this.pendingServiceCalls) {
       clearTimeout(pending.timer);
@@ -2441,6 +2639,10 @@ var _RosbridgeClient = class _RosbridgeClient {
       this.reconnectTimer = null;
     }
     if (this.ws) {
+      this.ws.onopen = null;
+      this.ws.onmessage = null;
+      this.ws.onerror = null;
+      this.ws.onclose = null;
       try {
         this.ws.close();
       } catch {
@@ -2537,7 +2739,7 @@ var ProtocolManager = class {
   /**
    * Create and connect a protocol client for the given options.
    *
-   * For `protocol: 'zenoh'`, throws a clear "planned for v0.2.0" error —
+   * For `protocol: 'zenoh'`, throws a clear "planned for v0.3.0" error —
    * the v0.1.0 release does not ship a Zenoh implementation.
    */
   async connect(options) {
@@ -2545,7 +2747,8 @@ var ProtocolManager = class {
       await this.activeClient.disconnect();
     }
     const client = this.createClient(options);
-    const scheme = options.secure ? "wss" : "ws";
+    const pastedTls = /^\s*(wss|https):\/\//i.test(options.host);
+    const scheme = options.secure ?? pastedTls ? "wss" : "ws";
     const port = options.port || DEFAULT_PORTS[options.protocol];
     const host = sanitizeHost(options.host);
     const url = `${scheme}://${host}:${port}`;
@@ -2556,7 +2759,13 @@ var ProtocolManager = class {
         `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);
+    try {
+      await client.connect(url);
+    } catch (err) {
+      await client.disconnect().catch(() => {
+      });
+      throw err;
+    }
     this.activeClient = client;
     this.activeOptions = options;
     return client;
@@ -2590,7 +2799,7 @@ var ProtocolManager = class {
       case "rosbridge":
         return new RosbridgeClient(this.clientOptions);
       case "zenoh":
-        throw new Error("Zenoh support is planned for v0.2.0");
+        throw new Error("Zenoh support is planned for v0.3.0");
       default: {
         const exhaustive = options.protocol;
         throw new Error(`Unknown protocol: ${String(exhaustive)}`);
@@ -2599,6 +2808,11 @@ var ProtocolManager = class {
   }
 };
 
+// src/materializeBytes.ts
+function materializeBytes(view) {
+  return new Uint8Array(view);
+}
+
 exports.DEFAULT_PORTS = DEFAULT_PORTS;
 exports.DEFAULT_PRESETS = DEFAULT_PRESETS;
 exports.FoxgloveClient = FoxgloveClient;
@@ -2610,6 +2824,8 @@ exports.getLagHistoryCsv = getLagHistoryCsv;
 exports.getLagStats = getLagStats;
 exports.getMaxLagMs = getMaxLagMs;
 exports.jsonSchemaToTemplate = jsonSchemaToTemplate;
+exports.matchesSchema = matchesSchema;
+exports.materializeBytes = materializeBytes;
 exports.schemaToTemplate = schemaToTemplate;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map