@formant/data-sdk 0.0.116 → 0.0.118

package/dist/data-sdk.es.js

@@ -19230,659 +19230,831 @@ const envLocal = urlParams$2.get("formant_local");
 if (envLocal) {
   FORMANT_API_URL = "https://api.formant.local";
 }
-class App {
-  static sendAppMessage(message) {
-    window.parent.postMessage(message, "*");
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+class DataChannel {
+  constructor(dataChannel) {
+    __publicField(this, "ready", false);
+    __publicField(this, "listeners", []);
+    __publicField(this, "openListeners", []);
+    __publicField(this, "closeListeners", []);
+    __publicField(this, "errorListeners", []);
+    __publicField(this, "binaryListeners", []);
+    __publicField(this, "error");
+    __publicField(this, "decoder", new TextDecoder());
+    this.dataChannel = dataChannel;
+    this.dataChannel.binaryType = "arraybuffer";
+    this.dataChannel.onopen = () => {
+      this.ready = true;
+      this.openListeners.forEach((listener) => listener());
+    };
+    this.dataChannel.onclose = () => {
+      this.ready = false;
+      this.closeListeners.forEach((listener) => listener());
+    };
+    this.dataChannel.onerror = (e) => {
+      console.error(e);
+      this.error = "An error occurred in DataChannel";
+      this.errorListeners.forEach((listener) => listener(e));
+    };
+    this.dataChannel.onmessage = (m) => {
+      this.listeners.forEach((_) => {
+        const d = new Uint8Array(m.data);
+        const s = this.decoder.decode(d);
+        _(s);
+      });
+      this.binaryListeners.forEach((_) => {
+        _(new Uint8Array(m.data));
+      });
+    };
   }
-  static getCurrentModuleContext() {
-    let urlParams2 = new URLSearchParams("");
-    if (typeof window !== "undefined") {
-      urlParams2 = new URLSearchParams(window.location.search);
-    }
-    const moduleName2 = urlParams2.get("module");
-    return moduleName2;
+  addOpenListener(listener) {
+    this.openListeners.push(listener);
   }
-  static async getCurrentModuleConfiguration() {
-    let urlParams2 = new URLSearchParams("");
-    if (typeof window !== "undefined") {
-      urlParams2 = new URLSearchParams(window.location.search);
-    }
-    const configurationId = urlParams2.get("configuration");
-    if (configurationId === null || configurationId.trim() === "") {
-      return void 0;
-    }
-    const response = await fetch(
-      `${FORMANT_API_URL}/v1/admin/module-configurations/` + configurationId,
-      {
-        headers: {
-          "Content-Type": "application/json",
-          Authorization: "Bearer " + Authentication.token
-        }
-      }
-    );
-    const moduleConfiguration = await response.json();
-    return moduleConfiguration.configuration;
+  removeOpenListener(listener) {
+    this.openListeners = this.openListeners.filter((_) => _ !== listener);
   }
-  static isModule() {
-    return this.getCurrentModuleContext() !== null;
+  addCloseListener(listener) {
+    this.closeListeners.push(listener);
   }
-  static goToTime(date) {
-    this.sendAppMessage({
-      type: "go_to_time",
-      time: date.getTime()
-    });
+  removeCloseListener(listener) {
+    this.closeListeners = this.closeListeners.filter((l) => l !== listener);
   }
-  static goToDevice(deviceId) {
-    this.sendAppMessage({
-      type: "go_to_device",
-      deviceId
-    });
+  addErrorListener(listener) {
+    this.errorListeners.push(listener);
   }
-  static showMessage(message) {
-    this.sendAppMessage({ type: "show_message", message });
+  removeErrorListener(listener) {
+    this.errorListeners = this.errorListeners.filter((l) => l !== listener);
   }
-  static requestModuleData() {
-    const moduleName2 = this.getCurrentModuleContext();
-    if (!moduleName2) {
-      throw new Error("No module context");
+  async waitTilReady() {
+    if (this.ready) {
+      return true;
     }
-    this.sendAppMessage({
-      type: "request_module_data",
-      module: moduleName2
+    const p = new Promise((resolve, reject) => {
+      let a2 = window.setInterval(() => {
+        if (this.ready) {
+          window.clearInterval(a2);
+          resolve(true);
+        }
+        if (this.error) {
+          reject(this.error);
+        }
+      }, 10);
     });
+    return p;
   }
-  static setModuleDateTimeRange(beforeInMilliseconds, afterInMilliseconds) {
-    const moduleName2 = this.getCurrentModuleContext();
-    if (!moduleName2) {
-      throw new Error("No module context");
+  send(data) {
+    if (!this.ready) {
+      throw new Error("Connection has been closed");
     }
-    this.sendAppMessage({
-      type: "set_module_data_time_range",
-      module: moduleName2,
-      before: beforeInMilliseconds,
-      after: afterInMilliseconds || 0
-    });
+    this.dataChannel.send(data);
   }
-  static refreshAuthToken() {
-    const moduleName2 = this.getCurrentModuleContext();
-    if (!moduleName2) {
-      throw new Error("No module context");
+  sendBinary(data) {
+    if (!this.ready) {
+      throw new Error("Connection has been closed");
     }
-    this.sendAppMessage({
-      type: "refresh_auth_token",
-      module: moduleName2
-    });
+    this.dataChannel.send(data);
   }
-  static sendChannelData(channel, data) {
-    const moduleName2 = this.getCurrentModuleContext();
-    if (!moduleName2) {
-      throw new Error("No module context");
+  addListener(listener) {
+    this.listeners.push(listener);
+  }
+  removeListener(listener) {
+    const i = this.listeners.indexOf(listener);
+    if (i === -1) {
+      throw new Error("Could not find data channel listener to remove");
     }
-    this.sendAppMessage({
-      type: "send_channel_data",
-      source: moduleName2,
-      channel,
-      data
-    });
+    if (this.error) {
+      throw new Error(this.error);
+    }
+    this.listeners.splice(i, 1);
   }
-  static setupModuleMenus(menus) {
-    const moduleName2 = this.getCurrentModuleContext();
-    if (!moduleName2) {
-      throw new Error("No module context");
+  addBinaryListener(listener) {
+    this.binaryListeners.push(listener);
+  }
+  removeBinaryListener(listener) {
+    const i = this.binaryListeners.indexOf(listener);
+    if (i === -1) {
+      throw new Error("Could not find data channel listener to remove");
     }
-    this.sendAppMessage({
-      type: "setup_module_menus",
-      module: moduleName2,
-      menus
-    });
+    if (this.error) {
+      throw new Error(this.error);
+    }
+    this.binaryListeners.splice(i, 1);
   }
-  static addMenuListener(handler) {
-    window.addEventListener("message", (event) => {
-      const msg = event.data;
-      if (msg.type === "module_menu_item_clicked") {
-        handler(msg.menu);
-      }
-    });
+}
+class CaptureStream {
+  constructor(captureSession) {
+    __publicField(this, "token");
+    this.captureSession = captureSession;
   }
-  static addAccessTokenRefreshListener(handler) {
-    window.addEventListener("message", (event) => {
-      const msg = event.data;
-      if (msg.type === "auth_token") {
-        handler(msg.token);
+  async ingestJSON(value) {
+    if (!this.token) {
+      const result = await fetch(
+        `${FORMANT_API_URL}/v1/admin/capture-sessions/${this.captureSession.code}/authenticate`,
+        {
+          method: "POST"
+        }
+      );
+      const authInfo = await result.json();
+      this.token = authInfo.token;
+    }
+    await fetch(`${FORMANT_API_URL}/v1/ingest`, {
+      method: "POST",
+      body: JSON.stringify({
+        deviceId: this.captureSession.deviceId,
+        name: this.captureSession.streamName,
+        type: "json",
+        points: [[Date.now(), JSON.stringify(value)]]
+      }),
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: "Bearer " + this.token
       }
     });
   }
-  static addModuleDataListener(handler) {
-    const moduleName2 = this.getCurrentModuleContext();
-    if (moduleName2) {
-      this.sendAppMessage({ type: "request_module_data", module: moduleName2 });
-    }
-    window.addEventListener("message", (event) => {
-      const msg = event.data;
-      if (msg.type === "module_data") {
-        handler({
-          streams: msg.streams,
-          time: msg.time,
-          queryRange: msg.queryRange
+}
+class Manipulator {
+  constructor(device, config) {
+    __publicField(this, "currentListeners", []);
+    __publicField(this, "onRealtimeMessage", (_peerId, message) => {
+      if (message.payload.jointState) {
+        this.currentListeners.forEach((listener) => {
+          if (message.payload.jointState)
+            listener(message.payload.jointState);
         });
       }
     });
+    this.device = device;
+    this.config = config;
   }
-  static addModuleConfigurationListener(handler) {
-    window.addEventListener("message", (event) => {
-      const msg = event.data;
-      if (msg.type === "module_configuration") {
-        handler(msg);
-      }
-    });
+  async synchronize() {
+    this.device.addRealtimeListener(this.onRealtimeMessage);
+    this.device.startListeningToRealtimeDataStream(
+      this.config.currentJointStateStream
+    );
   }
-  static addChannelDataListener(channel, handler) {
-    window.addEventListener("message", (event) => {
-      const msg = event.data;
-      if (msg.type === "channel_data" && msg.channel === channel) {
-        handler({
-          source: msg.source,
-          data: msg.data
-        });
-      }
-    });
+  async desynchronize() {
+    this.device.removeRealtimeListener(this.onRealtimeMessage);
+    this.device.stopListeningToRealtimeDataStream(
+      this.config.currentJointStateStream
+    );
   }
-  static requestOverviewDevices(handler) {
-    this.sendAppMessage({ type: "request_devices" });
-    window.addEventListener("message", (event) => {
-      const msg = event.data;
-      handler(msg);
-    });
+  async addCurrentJointStateListener(listener) {
+    this.currentListeners.push(listener);
   }
 }
-const _Authentication = class {
-  static async login(email, password) {
-    try {
-      const result = await fetch(`${FORMANT_API_URL}/v1/admin/auth/login`, {
-        method: "POST",
-        body: JSON.stringify({ email, password }),
-        headers: {
-          "Content-Type": "application/json"
-        }
-      });
-      const auth = await result.json();
-      if (result.status !== 200) {
-        throw new Error(auth.message);
-      }
-      await _Authentication.loginWithToken(
-        auth.authentication.accessToken,
-        auth.authentication.refreshToken
-      );
-      return auth.authentication;
-    } catch (e) {
-      _Authentication.waitingForAuth.forEach((_) => _(false));
-      _Authentication.waitingForAuth = [];
-      return Promise.reject(e);
+class RequestDataChannel {
+  constructor(device, channel_name, timeout) {
+    __publicField(this, "channel");
+    __publicField(this, "requestIdToResponseMap", /* @__PURE__ */ new Map());
+    this.device = device;
+    this.channel_name = channel_name;
+    this.timeout = timeout;
+  }
+  addOpenListener(listener) {
+    defined(this.channel, "channel not initalized").addOpenListener(listener);
+  }
+  removeOpenListener(listener) {
+    defined(this.channel, "channel not initalized").removeOpenListener(
+      listener
+    );
+  }
+  addCloseListener(listener) {
+    defined(this.channel, "channel not initalized").addCloseListener(listener);
+  }
+  removeCloseListener(listener) {
+    defined(this.channel, "channel not initalized").removeCloseListener(
+      listener
+    );
+  }
+  addErrorListener(listener) {
+    defined(this.channel, "channel not initalized").addErrorListener(listener);
+  }
+  removeErrorListener(listener) {
+    defined(this.channel, "channel not initalized").removeErrorListener(
+      listener
+    );
+  }
+}
+class BinaryRequestDataChannel extends RequestDataChannel {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "RESPONSE_SUCCESS_BYTE", 0);
+    __publicField(this, "decoder", new TextDecoder());
+  }
+  generateBinaryId() {
+    const id = new Uint8Array(16);
+    for (let i = 0; i < id.length; i++) {
+      id[i] = Math.floor(Math.random() * 256);
     }
+    return id;
   }
-  static async loginWithToken(token, refreshToken) {
-    const tokenData = JSON.parse(atob(token.split(".")[1]));
-    try {
-      let userId;
-      _Authentication.isShareToken = tokenData["formant:claims"] && tokenData["formant:claims"].type == "share";
-      if (tokenData["formant:claims"]) {
-        _Authentication.currentOrganization = tokenData["formant:claims"].organizationId;
-      }
-      if (tokenData["custom:organization_id"]) {
-        _Authentication.currentOrganization = tokenData["custom:organization_id"];
+  async initialize() {
+    this.channel = await this.device.createCustomDataChannel(this.channel_name);
+    this.channel.addBinaryListener((message) => {
+      const binaryId = message.slice(0, 16);
+      const id = binaryId.toString();
+      if (id.length === 0) {
+        throw new Error("Invalid response");
       }
-      if (!_Authentication.isShareToken) {
-        userId = tokenData.sub;
+      const response = message.slice(16);
+      if (response.length === 0) {
+        throw new Error("Invalid response");
       }
-      if (tokenData["formant:claims"] && tokenData["formant:claims"].userId) {
-        userId = tokenData["formant:claims"].userId;
+      if (this.requestIdToResponseMap.has(id)) {
+        this.requestIdToResponseMap.set(id, response);
       }
-      if (userId) {
-        const result = await fetch(
-          `${FORMANT_API_URL}/v1/admin/users/${userId}`,
-          {
-            method: "GET",
-            headers: {
-              "Content-Type": "application/json",
-              Authorization: "Bearer " + token
-            }
+    });
+  }
+  async request(data) {
+    if (!this.channel) {
+      await this.initialize();
+    }
+    if (!this.channel) {
+      throw new Error("Failed to create channel");
+    }
+    const { channel, requestIdToResponseMap, timeout } = this;
+    await channel.waitTilReady();
+    const binaryId = this.generateBinaryId();
+    const id = binaryId.toString();
+    requestIdToResponseMap.set(id, true);
+    channel.sendBinary(new Uint8Array([...binaryId, ...data]));
+    const start = new Date().getTime();
+    while (new Date().getTime() < start + timeout) {
+      await delay(50);
+      if (requestIdToResponseMap.has(id)) {
+        const response = requestIdToResponseMap.get(id);
+        if (response !== true) {
+          requestIdToResponseMap.delete(id);
+          const success = response[0] === this.RESPONSE_SUCCESS_BYTE;
+          const payload = response.slice(1);
+          if (success) {
+            return payload;
+          } else {
+            console.error({
+              name: "AdapterError",
+              message: this.decoder.decode(payload)
+            });
+            throw new Error("Binary request datachannel adapter error");
           }
-        );
-        const data = await result.json();
-        if (result.status !== 200) {
-          throw new Error(data.message);
         }
-        _Authentication.currentUser = data;
       }
-      _Authentication.token = token;
-      _Authentication.waitingForAuth.forEach((_) => _(true));
-    } catch (e) {
-      console.error(e);
-      _Authentication.waitingForAuth.forEach((_) => _(false));
-    }
-    _Authentication.waitingForAuth = [];
-    if (refreshToken) {
-      _Authentication.refreshToken = refreshToken;
-      setInterval(async () => {
-        if (_Authentication.refreshToken) {
-          const result = await fetch(
-            `${FORMANT_API_URL}/v1/admin/auth/refresh`,
-            {
-              method: "POST",
-              headers: {
-                "Content-Type": "application/json"
-              },
-              body: JSON.stringify({
-                refreshToken: _Authentication.refreshToken
-              })
-            }
-          );
-          const refreshData = await result.json();
-          _Authentication.token = refreshData.authentication.accessToken;
-        }
-      }, 1e3 * 60 * 60);
     }
+    requestIdToResponseMap.delete(id);
+    console.error({
+      name: "TimeoutError",
+      message: `Request timed out after ${timeout / 1e3} seconds`
+    });
+    throw new Error("Binary request data channel request timed out");
   }
-  static isAuthenticated() {
-    return _Authentication.token !== void 0;
+}
+class TextRequestDataChannel extends RequestDataChannel {
+  generateTextId() {
+    return Math.random().toString(36).substring(2) + "-" + Math.random().toString(36).substring(2);
   }
-  static getCurrentUser() {
-    return _Authentication.currentUser;
+  async initialize() {
+    this.channel = await this.device.createCustomDataChannel(this.channel_name);
+    this.channel.addListener((message) => {
+      const response = JSON.parse(message);
+      const { id, data, error } = response;
+      if (!id) {
+        throw new Error("Invalid response");
+      }
+      if (!data && !error) {
+        throw new Error("Invalid response");
+      }
+      if (this.requestIdToResponseMap.has(id)) {
+        this.requestIdToResponseMap.set(id, response);
+      }
+    });
   }
-  static async waitTilAuthenticated() {
-    if (_Authentication.token !== void 0) {
-      return true;
-    } else {
-      return new Promise((resolve) => {
-        _Authentication.waitingForAuth.push(function(result) {
-          resolve(result);
-        });
-      });
+  async request(data) {
+    if (!this.channel) {
+      await this.initialize();
     }
-  }
-  static async listenForRefresh() {
-    App.addAccessTokenRefreshListener((token) => {
-      this.loginWithToken(token);
+    if (!this.channel) {
+      throw new Error("Failed to create channel");
+    }
+    const { channel, requestIdToResponseMap, timeout } = this;
+    await channel.waitTilReady();
+    const id = this.generateTextId();
+    requestIdToResponseMap.set(id, true);
+    channel.send(
+      JSON.stringify({
+        id,
+        data
+      })
+    );
+    const start = new Date().getTime();
+    while (new Date().getTime() < start + timeout) {
+      await delay(50);
+      if (requestIdToResponseMap.has(id)) {
+        const response = requestIdToResponseMap.get(id);
+        if (response !== true) {
+          requestIdToResponseMap.delete(id);
+          const { data: data2, error } = response;
+          if (data2) {
+            return data2;
+          }
+          if (error) {
+            console.error({
+              name: "AdapterError",
+              message: error
+            });
+            throw new Error("Text request datachannel adapter error");
+          }
+        }
+      }
+    }
+    requestIdToResponseMap.delete(id);
+    console.error({
+      name: "TimeoutError",
+      message: `Request timed out after ${timeout / 1e3} seconds`
     });
-    setInterval(async () => {
-      App.refreshAuthToken();
-    }, 1e3 * 60 * 60);
+    throw new Error("Text request datachannel request timed out");
   }
-};
-let Authentication = _Authentication;
-__publicField(Authentication, "token");
-__publicField(Authentication, "refreshToken");
-__publicField(Authentication, "currentUser");
-__publicField(Authentication, "currentOrganization");
-__publicField(Authentication, "isShareToken", false);
-__publicField(Authentication, "defaultDeviceId");
-__publicField(Authentication, "waitingForAuth", []);
-function delay(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
 }
-class DataChannel {
-  constructor(dataChannel) {
-    __publicField(this, "ready", false);
-    __publicField(this, "listeners", []);
-    __publicField(this, "openListeners", []);
-    __publicField(this, "closeListeners", []);
-    __publicField(this, "errorListeners", []);
-    __publicField(this, "binaryListeners", []);
-    __publicField(this, "error");
-    __publicField(this, "decoder", new TextDecoder());
-    this.dataChannel = dataChannel;
-    this.dataChannel.binaryType = "arraybuffer";
-    this.dataChannel.onopen = () => {
-      this.ready = true;
-      this.openListeners.forEach((listener) => listener());
-    };
-    this.dataChannel.onclose = () => {
-      this.ready = false;
-      this.closeListeners.forEach((listener) => listener());
-    };
-    this.dataChannel.onerror = (e) => {
-      console.error(e);
-      this.error = "An error occurred in DataChannel";
-      this.errorListeners.forEach((listener) => listener(e));
-    };
-    this.dataChannel.onmessage = (m) => {
-      this.listeners.forEach((_) => {
-        const d = new Uint8Array(m.data);
-        const s = this.decoder.decode(d);
-        _(s);
-      });
-      this.binaryListeners.forEach((_) => {
-        _(new Uint8Array(m.data));
-      });
-    };
-  }
-  addOpenListener(listener) {
-    this.openListeners.push(listener);
-  }
-  removeOpenListener(listener) {
-    this.openListeners = this.openListeners.filter((_) => _ !== listener);
+const urlParams$1 = new URLSearchParams(window.location.search);
+const rtcClientVersion = urlParams$1.get("rtc_client");
+const SessionType = {
+  Teleop: 1,
+  Observe: 3
+};
+class Device {
+  constructor(id, name, organizationId) {
+    __publicField(this, "rtcClient");
+    __publicField(this, "remoteDevicePeerId");
+    __publicField(this, "realtimeListeners", []);
+    __publicField(this, "handleMessage", (peerId, message) => {
+      this.realtimeListeners.forEach((_) => _(peerId, message));
+    });
+    this.id = id;
+    this.name = name;
+    this.organizationId = organizationId;
   }
-  addCloseListener(listener) {
-    this.closeListeners.push(listener);
+  async getLatestTelemetry() {
+    const data = await fetch(
+      `${FORMANT_API_URL}/v1/queries/stream-current-value`,
+      {
+        method: "POST",
+        body: JSON.stringify({
+          deviceIds: [this.id]
+        }),
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: "Bearer " + Authentication.token
+        }
+      }
+    );
+    const telemetry = await data.json();
+    return telemetry.items;
   }
-  removeCloseListener(listener) {
-    this.closeListeners = this.closeListeners.filter((l) => l !== listener);
+  async getConfiguration() {
+    let result = await fetch(`${FORMANT_API_URL}/v1/admin/devices/${this.id}`, {
+      method: "GET",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: "Bearer " + Authentication.token
+      }
+    });
+    const device = await result.json();
+    if (!device.state.reportedConfiguration) {
+      throw new Error(
+        "Device has no configuration, has it ever been turned on?"
+      );
+    }
+    const version = device.state.reportedConfiguration.version;
+    result = await fetch(
+      `${FORMANT_API_URL}/v1/admin/devices/${this.id}/configurations/${version}`,
+      {
+        method: "GET",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: "Bearer " + Authentication.token
+        }
+      }
+    );
+    const config = await result.json();
+    return config.document;
   }
-  addErrorListener(listener) {
-    this.errorListeners.push(listener);
+  async getFileUrl(fileId) {
+    const result = await fetch(`${FORMANT_API_URL}/v1/admin/files/query`, {
+      method: "POST",
+      body: JSON.stringify({
+        fileIds: [fileId]
+      }),
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: "Bearer " + Authentication.token
+      }
+    });
+    const files = await result.json();
+    return files.fileUrls;
   }
-  removeErrorListener(listener) {
-    this.errorListeners = this.errorListeners.filter((l) => l !== listener);
+  getRealtimeStatus() {
+    if (this.rtcClient && this.remoteDevicePeerId) {
+      return this.rtcClient.getConnectionStatus(this.remoteDevicePeerId);
+    } else {
+      throw new Error(`Realtime connection hasn't been started for ${this.id}`);
+    }
   }
-  async waitTilReady() {
-    if (this.ready) {
-      return true;
+  getRealtimePing() {
+    if (this.rtcClient && this.remoteDevicePeerId) {
+      return this.rtcClient.getPing(this.remoteDevicePeerId);
+    } else {
+      throw new Error(`Realtime connection hasn't been started for ${this.id}`);
     }
-    const p = new Promise((resolve, reject) => {
-      let a2 = window.setInterval(() => {
-        if (this.ready) {
-          window.clearInterval(a2);
-          resolve(true);
-        }
-        if (this.error) {
-          reject(this.error);
+  }
+  async startRealtimeConnection(sessionType) {
+    if (!this.rtcClient) {
+      let rtcClient;
+      if (rtcClientVersion === "1") {
+        rtcClient = new dist.exports.RtcClientV1({
+          signalingClient: new dist.exports.RtcSignalingClient(
+            FORMANT_API_URL + "/v1/signaling"
+          ),
+          getToken: async () => defined(
+            Authentication.token,
+            "Realtime when user isn't authorized"
+          ),
+          receive: this.handleMessage
+        });
+      } else {
+        rtcClient = new dist.exports.RtcClient({
+          signalingClient: new dist.exports.SignalingPromiseClient(
+            FORMANT_API_URL,
+            null,
+            null
+          ),
+          getToken: async () => {
+            return defined(
+              Authentication.token,
+              "Realtime when user isn't authorized"
+            );
+          },
+          receive: this.handleMessage,
+          sessionType
+        });
+      }
+      if (rtcClient.isReady) {
+        while (!rtcClient.isReady()) {
+          await delay(100);
         }
-      }, 10);
-    });
-    return p;
-  }
-  send(data) {
-    if (!this.ready) {
-      throw new Error("Connection has been closed");
+      }
+      const peers = await rtcClient.getPeers();
+      const devicePeer = peers.find((_) => _.deviceId === this.id);
+      if (!devicePeer) {
+        throw new Error("Cannot find peer, is the robot offline?");
+      }
+      this.remoteDevicePeerId = devicePeer.id;
+      await rtcClient.connect(this.remoteDevicePeerId);
+      while (rtcClient.getConnectionStatus(this.remoteDevicePeerId) !== "connected") {
+        await delay(100);
+      }
+      this.rtcClient = rtcClient;
+    } else {
+      throw new Error(
+        `Already created realtime connection to device ${this.id}`
+      );
     }
-    this.dataChannel.send(data);
   }
-  sendBinary(data) {
-    if (!this.ready) {
-      throw new Error("Connection has been closed");
-    }
-    this.dataChannel.send(data);
+  async sendRealtimeMessage(message, config = {
+    channelLabel: "stream.reliable"
+  }) {
+    const client = defined(
+      this.rtcClient,
+      "Realtime connection has not been started"
+    );
+    const devicePeer = await this.getRemotePeer();
+    client.send(defined(devicePeer).id, message, config);
   }
-  addListener(listener) {
-    this.listeners.push(listener);
+  addRealtimeListener(listener) {
+    this.realtimeListeners.push(listener);
   }
-  removeListener(listener) {
-    const i = this.listeners.indexOf(listener);
+  removeRealtimeListener(listener) {
+    const i = this.realtimeListeners.indexOf(listener);
     if (i === -1) {
-      throw new Error("Could not find data channel listener to remove");
-    }
-    if (this.error) {
-      throw new Error(this.error);
+      throw new Error("Could not find realtime listener to remove");
     }
-    this.listeners.splice(i, 1);
-  }
-  addBinaryListener(listener) {
-    this.binaryListeners.push(listener);
+    this.realtimeListeners.splice(i, 1);
   }
-  removeBinaryListener(listener) {
-    const i = this.binaryListeners.indexOf(listener);
-    if (i === -1) {
-      throw new Error("Could not find data channel listener to remove");
+  async getRealtimeAudioStreams() {
+    var _a, _b, _c, _d, _e, _f;
+    const document2 = await this.getConfiguration();
+    const streams = [];
+    for (const _ of (_b = (_a = document2.teleop) == null ? void 0 : _a.hardwareStreams) != null ? _b : []) {
+      if (_.rtcStreamType === "audio-chunk") {
+        streams.push({
+          name: _.name
+        });
+      }
     }
-    if (this.error) {
-      throw new Error(this.error);
+    for (const _ of (_d = (_c = document2.teleop) == null ? void 0 : _c.rosStreams) != null ? _d : []) {
+      if (_.topicType == "audio_common_msgs/AudioData") {
+        streams.push({
+          name: _.topicName
+        });
+      }
     }
-    this.binaryListeners.splice(i, 1);
-  }
-}
-class CaptureStream {
-  constructor(captureSession) {
-    __publicField(this, "token");
-    this.captureSession = captureSession;
+    for (const _ of (_f = (_e = document2.teleop) == null ? void 0 : _e.customStreams) != null ? _f : []) {
+      if (_.rtcStreamType === "audio-chunk") {
+        streams.push({
+          name: _.name
+        });
+      }
+    }
+    return streams;
   }
-  async ingestJSON(value) {
-    if (!this.token) {
-      const result = await fetch(
-        `${FORMANT_API_URL}/v1/admin/capture-sessions/${this.captureSession.code}/authenticate`,
-        {
-          method: "POST"
-        }
-      );
-      const authInfo = await result.json();
-      this.token = authInfo.token;
+  async getRealtimeVideoStreams() {
+    var _a, _b, _c, _d, _e, _f;
+    const document2 = await this.getConfiguration();
+    const streams = [];
+    for (const _ of (_b = (_a = document2.teleop) == null ? void 0 : _a.hardwareStreams) != null ? _b : []) {
+      if (_.rtcStreamType === "h264-video-frame") {
+        streams.push({
+          name: _.name
+        });
+      }
     }
-    await fetch(`${FORMANT_API_URL}/v1/ingest`, {
-      method: "POST",
-      body: JSON.stringify({
-        deviceId: this.captureSession.deviceId,
-        name: this.captureSession.streamName,
-        type: "json",
-        points: [[Date.now(), JSON.stringify(value)]]
-      }),
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: "Bearer " + this.token
+    for (const _ of (_d = (_c = document2.teleop) == null ? void 0 : _c.rosStreams) != null ? _d : []) {
+      if (_.topicType == "formant/H264VideoFrame") {
+        streams.push({
+          name: _.topicName
+        });
       }
-    });
-  }
-}
-class Manipulator {
-  constructor(device, config) {
-    __publicField(this, "currentListeners", []);
-    __publicField(this, "onRealtimeMessage", (_peerId, message) => {
-      if (message.payload.jointState) {
-        this.currentListeners.forEach((listener) => {
-          if (message.payload.jointState)
-            listener(message.payload.jointState);
+    }
+    for (const _ of (_f = (_e = document2.teleop) == null ? void 0 : _e.customStreams) != null ? _f : []) {
+      if (_.rtcStreamType === "h264-video-frame") {
+        streams.push({
+          name: _.name
         });
       }
-    });
-    this.device = device;
-    this.config = config;
+    }
+    return streams;
   }
-  async synchronize() {
-    this.device.addRealtimeListener(this.onRealtimeMessage);
-    this.device.startListeningToRealtimeDataStream(
-      this.config.currentJointStateStream
-    );
+  async getRealtimeManipulators() {
+    var _a;
+    const document2 = await this.getConfiguration();
+    const manipulators = [];
+    for (const _ of (_a = document2.teleop.rosStreams) != null ? _a : []) {
+      if (_.topicType == "sensor_msgs/JointState") {
+        manipulators.push(
+          new Manipulator(this, {
+            currentJointStateStream: { name: _.topicName },
+            plannedJointStateStream: _.plannedTopic ? { name: _.plannedTopic } : void 0,
+            planValidStream: _.planValidTopic ? { name: _.planValidTopic } : void 0,
+            endEffectorStream: _.endEffectorTopic ? { name: _.endEffectorTopic } : void 0,
+            endEffectorLinkName: _.endEffectorLinkName,
+            baseReferenceFrame: _.baseReferenceFrame,
+            localFrame: _.localFrame
+          })
+        );
+      }
+    }
+    return manipulators;
   }
-  async desynchronize() {
-    this.device.removeRealtimeListener(this.onRealtimeMessage);
-    this.device.stopListeningToRealtimeDataStream(
-      this.config.currentJointStateStream
+  async startListeningToRealtimeVideo(stream) {
+    const client = defined(
+      this.rtcClient,
+      "Realtime connection has not been started"
     );
+    const devicePeer = await this.getRemotePeer();
+    client.controlRemoteStream(defined(devicePeer).id, {
+      streamName: stream.name,
+      enable: true,
+      pipeline: "rtc"
+    });
   }
-  async addCurrentJointStateListener(listener) {
-    this.currentListeners.push(listener);
-  }
-}
-class RequestDataChannel {
-  constructor(device, channel_name, timeout) {
-    __publicField(this, "channel");
-    __publicField(this, "requestIdToResponseMap", /* @__PURE__ */ new Map());
-    this.device = device;
-    this.channel_name = channel_name;
-    this.timeout = timeout;
+  async stopListeningToRealtimeVideo(stream) {
+    const client = defined(
+      this.rtcClient,
+      "Realtime connection has not been started"
+    );
+    const devicePeer = await this.getRemotePeer();
+    client.controlRemoteStream(defined(devicePeer).id, {
+      streamName: stream.name,
+      enable: false,
+      pipeline: "rtc"
+    });
   }
-  addOpenListener(listener) {
-    defined(this.channel, "channel not initalized").addOpenListener(listener);
+  async startListeningToRealtimeDataStream(stream) {
+    const client = defined(
+      this.rtcClient,
+      "Realtime connection has not been started"
+    );
+    const devicePeer = await this.getRemotePeer();
+    client.controlRemoteStream(defined(devicePeer).id, {
+      streamName: stream.name,
+      enable: true,
+      pipeline: "rtc"
+    });
   }
-  removeOpenListener(listener) {
-    defined(this.channel, "channel not initalized").removeOpenListener(
-      listener
+  async stopListeningToRealtimeDataStream(stream) {
+    const client = defined(
+      this.rtcClient,
+      "Realtime connection has not been started"
     );
+    const devicePeer = await this.getRemotePeer();
+    client.controlRemoteStream(defined(devicePeer).id, {
+      streamName: stream.name,
+      enable: false,
+      pipeline: "rtc"
+    });
   }
-  addCloseListener(listener) {
-    defined(this.channel, "channel not initalized").addCloseListener(listener);
+  async enableRealtimeTelemetryPriorityIngestion(streamName) {
+    const client = defined(
+      this.rtcClient,
+      "Realtime connection has not been started"
+    );
+    const devicePeer = await this.getRemotePeer();
+    client.controlRemoteStream(defined(devicePeer).id, {
+      streamName,
+      enablePriorityUpload: true,
+      pipeline: "telemetry"
+    });
   }
-  removeCloseListener(listener) {
-    defined(this.channel, "channel not initalized").removeCloseListener(
-      listener
+  async changeStreamAudioType(streamName, newFormat) {
+    const client = defined(
+      this.rtcClient,
+      "Realtime connection has not been started"
     );
+    const devicePeer = await this.getRemotePeer();
+    client.controlRemoteStream(defined(devicePeer).id, {
+      streamName,
+      setAudioFormat: newFormat
+    });
   }
-  addErrorListener(listener) {
-    defined(this.channel, "channel not initalized").addErrorListener(listener);
+  async disableRealtimeTelemetryPriorityIngestion(streamName) {
+    const client = defined(
+      this.rtcClient,
+      "Realtime connection has not been started"
+    );
+    const devicePeer = await this.getRemotePeer();
+    client.controlRemoteStream(defined(devicePeer).id, {
+      streamName,
+      enablePriorityUpload: false,
+      pipeline: "telemetry"
+    });
   }
-  removeErrorListener(listener) {
-    defined(this.channel, "channel not initalized").removeErrorListener(
-      listener
+  async getRemotePeer() {
+    const peers = await defined(
+      this.rtcClient,
+      "Realtime connection has not been started"
+    ).getPeers();
+    const devicePeer = peers.find((_) => _.deviceId === this.id);
+    return defined(
+      devicePeer,
+      "Could not find remote peer for device " + this.id
     );
   }
-}
-class BinaryRequestDataChannel extends RequestDataChannel {
-  constructor() {
-    super(...arguments);
-    __publicField(this, "RESPONSE_SUCCESS_BYTE", 0);
-    __publicField(this, "decoder", new TextDecoder());
+  async stopRealtimeConnection() {
+    if (this.rtcClient) {
+      await this.rtcClient.disconnect(this.id);
+    } else {
+      throw new Error(`Realtime connection hasn't been started for ${this.id}`);
+    }
   }
-  generateBinaryId() {
-    const id = new Uint8Array(16);
-    for (let i = 0; i < id.length; i++) {
-      id[i] = Math.floor(Math.random() * 256);
+  async isInRealtimeSession() {
+    let peers = await Fleet.getPeers();
+    let sessions = await Fleet.getRealtimeSessions();
+    let peer = peers.find((_) => _.deviceId === this.id);
+    if (peer) {
+      return sessions[peer.id].length > 0;
     }
-    return id;
+    return false;
   }
-  async initialize() {
-    this.channel = await this.device.createCustomDataChannel(this.channel_name);
-    this.channel.addBinaryListener((message) => {
-      const binaryId = message.slice(0, 16);
-      const id = binaryId.toString();
-      if (id.length === 0) {
-        throw new Error("Invalid response");
-      }
-      const response = message.slice(16);
-      if (response.length === 0) {
-        throw new Error("Invalid response");
-      }
-      if (this.requestIdToResponseMap.has(id)) {
-        this.requestIdToResponseMap.set(id, response);
+  async getAvailableCommands() {
+    const result = await fetch(
+      `${FORMANT_API_URL}/v1/admin/command-templates/`,
+      {
+        method: "GET",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: "Bearer " + Authentication.token
+        }
       }
-    });
+    );
+    const commands = await result.json();
+    return commands.items.map((i) => ({
+      name: i.name,
+      id: i.id,
+      command: i.command,
+      description: i.description,
+      parameterEnabled: i.parameterEnabled,
+      parameterValue: i.parameterValue,
+      parameterMeta: i.parameterMeta,
+      enabled: i.enabled
+    }));
   }
-  async request(data) {
-    if (!this.channel) {
-      await this.initialize();
-    }
-    if (!this.channel) {
-      throw new Error("Failed to create channel");
+  async sendCommand(name, data, time, metadata) {
+    var _a;
+    const commands = await this.getAvailableCommands();
+    const command = commands.find((_) => _.name === name);
+    if (!command) {
+      throw new Error(`Could not find command with name "${name}"`);
     }
-    const { channel, requestIdToResponseMap, timeout } = this;
-    await channel.waitTilReady();
-    const binaryId = this.generateBinaryId();
-    const id = binaryId.toString();
-    requestIdToResponseMap.set(id, true);
-    channel.sendBinary(new Uint8Array([...binaryId, ...data]));
-    const start = new Date().getTime();
-    while (new Date().getTime() < start + timeout) {
-      await delay(50);
-      if (requestIdToResponseMap.has(id)) {
-        const response = requestIdToResponseMap.get(id);
-        if (response !== true) {
-          requestIdToResponseMap.delete(id);
-          const success = response[0] === this.RESPONSE_SUCCESS_BYTE;
-          const payload = response.slice(1);
-          if (success) {
-            return payload;
-          } else {
-            console.error({
-              name: "AdapterError",
-              message: this.decoder.decode(payload)
-            });
-            throw new Error("Binary request datachannel adapter error");
-          }
-        }
+    let d;
+    if (data === void 0) {
+      if (command.parameterEnabled && command.parameterValue) {
+        d = command.parameterValue;
+      } else {
+        throw new Error(
+          "Command has no default parameter value, you must provide one"
+        );
       }
+    } else {
+      d = data;
     }
-    requestIdToResponseMap.delete(id);
-    console.error({
-      name: "TimeoutError",
-      message: `Request timed out after ${timeout / 1e3} seconds`
-    });
-    throw new Error("Binary request data channel request timed out");
-  }
-}
-class TextRequestDataChannel extends RequestDataChannel {
-  generateTextId() {
-    return Math.random().toString(36).substring(2) + "-" + Math.random().toString(36).substring(2);
-  }
-  async initialize() {
-    this.channel = await this.device.createCustomDataChannel(this.channel_name);
-    this.channel.addListener((message) => {
-      const response = JSON.parse(message);
-      const { id, data, error } = response;
-      if (!id) {
-        throw new Error("Invalid response");
-      }
-      if (!data && !error) {
-        throw new Error("Invalid response");
+    let parameter = {
+      value: d,
+      scrubberTime: (time || new Date()).toISOString(),
+      meta: {
+        ...command.parameterMeta,
+        ...metadata
       }
-      if (this.requestIdToResponseMap.has(id)) {
-        this.requestIdToResponseMap.set(id, response);
+    };
+    await fetch(`${FORMANT_API_URL}/v1/admin/commands`, {
+      method: "POST",
+      body: JSON.stringify({
+        commandTemplateId: command.id,
+        organizationId: this.organizationId,
+        deviceId: this.id,
+        command: command.command,
+        parameter,
+        userId: (_a = Authentication.currentUser) == null ? void 0 : _a.id
+      }),
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: "Bearer " + Authentication.token
       }
     });
   }
-  async request(data) {
-    if (!this.channel) {
-      await this.initialize();
-    }
-    if (!this.channel) {
-      throw new Error("Failed to create channel");
+  async createCustomDataChannel(channelName, rtcConfig) {
+    if (rtcClientVersion === "1") {
+      throw new Error(
+        "createCustomDataChannel is not supported in rtcClientVersion 1"
+      );
     }
-    const { channel, requestIdToResponseMap, timeout } = this;
-    await channel.waitTilReady();
-    const id = this.generateTextId();
-    requestIdToResponseMap.set(id, true);
-    channel.send(
-      JSON.stringify({
-        id,
-        data
-      })
+    const client = defined(
+      this.rtcClient,
+      "Realtime connection has not been started"
     );
-    const start = new Date().getTime();
-    while (new Date().getTime() < start + timeout) {
-      await delay(50);
-      if (requestIdToResponseMap.has(id)) {
-        const response = requestIdToResponseMap.get(id);
-        if (response !== true) {
-          requestIdToResponseMap.delete(id);
-          const { data: data2, error } = response;
-          if (data2) {
-            return data2;
-          }
-          if (error) {
-            console.error({
-              name: "AdapterError",
-              message: error
-            });
-            throw new Error("Text request datachannel adapter error");
-          }
+    const devicePeer = await this.getRemotePeer();
+    const p = await new Promise((resolve) => {
+      client.createCustomDataChannel(
+        defined(devicePeer).id,
+        channelName,
+        {
+          ordered: true,
+          ...rtcConfig
+        },
+        false,
+        (_peerId, channel) => {
+          const dataChannel = new DataChannel(channel);
+          resolve(dataChannel);
         }
+      );
+    });
+    await p.waitTilReady();
+    return p;
+  }
+  createCustomRequestDataChannel(channelName, timeout = 3e3) {
+    return new TextRequestDataChannel(this, channelName, timeout);
+  }
+  createCustomBinaryRequestDataChannel(channelName, timeout = 3e3) {
+    return new BinaryRequestDataChannel(this, channelName, timeout);
+  }
+  async createCaptureStream(streamName) {
+    const result = await fetch(`${FORMANT_API_URL}/v1/admin/capture-sessions`, {
+      method: "POST",
+      body: JSON.stringify({
+        deviceId: this.id,
+        streamName,
+        tags: {}
+      }),
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: "Bearer " + Authentication.token
       }
-    }
-    requestIdToResponseMap.delete(id);
-    console.error({
-      name: "TimeoutError",
-      message: `Request timed out after ${timeout / 1e3} seconds`
     });
-    throw new Error("Text request datachannel request timed out");
+    const captureSession = await result.json();
+    return new CaptureStream(captureSession);
   }
-}
-const urlParams$1 = new URLSearchParams(window.location.search);
-const rtcClientVersion = urlParams$1.get("rtc_client");
-const SessionType = {
-  Teleop: 1,
-  Observe: 3
-};
-class Device {
-  constructor(id, name, organizationId) {
-    __publicField(this, "rtcClient");
-    __publicField(this, "remoteDevicePeerId");
-    __publicField(this, "realtimeListeners", []);
-    __publicField(this, "handleMessage", (peerId, message) => {
-      this.realtimeListeners.forEach((_) => _(peerId, message));
-    });
-    this.id = id;
-    this.name = name;
-    this.organizationId = organizationId;
+  async getTelemetry(streamNameOrStreamNames, start, end, tags) {
+    return await Fleet.getTelemetry(
+      this.id,
+      streamNameOrStreamNames,
+      start,
+      end,
+      tags
+    );
   }
-  async getLatestTelemetry() {
-    const data = await fetch(
-      `${FORMANT_API_URL}/v1/queries/stream-current-value`,
+  async getTelemetryStreams() {
+    var _a, _b;
+    const config = await this.getConfiguration();
+    const result = await fetch(
+      `${FORMANT_API_URL}/v1/queries/metadata/stream-names`,
       {
         method: "POST",
         body: JSON.stringify({
@@ -19894,109 +20066,123 @@ class Device {
         }
       }
     );
-    const telemetry = await data.json();
-    return telemetry.items;
-  }
-  async getConfiguration() {
-    let result = await fetch(`${FORMANT_API_URL}/v1/admin/devices/${this.id}`, {
-      method: "GET",
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: "Bearer " + Authentication.token
+    const disabledList = [];
+    const onDemandList = [];
+    (_b = (_a = config.telemetry) == null ? void 0 : _a.streams) == null ? void 0 : _b.forEach((_) => {
+      if (_.disabled !== true) {
+        disabledList.push(_.name);
+      }
+      if (_.onDemand === true) {
+        onDemandList.push(_.name);
       }
     });
-    const device = await result.json();
-    if (!device.state.reportedConfiguration) {
-      throw new Error(
-        "Device has no configuration, has it ever been turned on?"
-      );
-    }
-    const version = device.state.reportedConfiguration.version;
-    result = await fetch(
-      `${FORMANT_API_URL}/v1/admin/devices/${this.id}/configurations/${version}`,
+    console.log(onDemandList);
+    const data = await result.json();
+    let streamNames = data.items.filter((_) => !disabledList.includes(_)).map((_) => ({ name: _, onDemand: onDemandList.includes(_) }));
+    return streamNames;
+  }
+  async createInterventionRequest(message, interventionType, interventionRequest, tags) {
+    const intervention = await fetch(
+      `${FORMANT_API_URL}/v1/admin/intervention-requests`,
       {
-        method: "GET",
+        method: "POST",
+        body: JSON.stringify({
+          message,
+          interventionType,
+          time: new Date().toISOString(),
+          deviceId: this.id,
+          tags,
+          data: interventionRequest
+        }),
         headers: {
           "Content-Type": "application/json",
           Authorization: "Bearer " + Authentication.token
         }
       }
     );
-    const config = await result.json();
-    return config.document;
+    const interventionJson = await intervention.json();
+    return interventionJson;
   }
-  async getFileUrl(fileId) {
-    const result = await fetch(`${FORMANT_API_URL}/v1/admin/files/query`, {
-      method: "POST",
-      body: JSON.stringify({
-        fileIds: [fileId]
-      }),
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: "Bearer " + Authentication.token
+  async addInterventionResponse(interventionId, interventionType, data) {
+    const response = await fetch(
+      `${FORMANT_API_URL}/v1/admin/intervention-responses`,
+      {
+        method: "POST",
+        body: JSON.stringify({
+          interventionId,
+          interventionType,
+          data
+        }),
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: "Bearer " + Authentication.token
+        }
       }
+    );
+    const interventionResponse = await response.json();
+    return interventionResponse;
+  }
+}
+class PeerDevice {
+  constructor(peerUrl) {
+    __publicField(this, "rtcClient");
+    __publicField(this, "remoteDevicePeerId");
+    __publicField(this, "realtimeListeners", []);
+    __publicField(this, "id");
+    __publicField(this, "handleMessage", (peerId, message) => {
+      this.realtimeListeners.forEach((_) => _(peerId, message));
     });
-    const files = await result.json();
-    return files.fileUrls;
+    this.peerUrl = peerUrl;
+  }
+  async getLatestTelemetry() {
+    const data = await fetch(`${this.peerUrl}/telemetry`);
+    const telemetry = await data.json();
+    const entries = Object.entries(telemetry);
+    return entries.map(([stream, latestValue]) => {
+      const v = {
+        deviceId: this.id,
+        streamName: stream,
+        streamType: "json",
+        currentValue: latestValue,
+        currentValueTime: latestValue.timestamp,
+        tags: {}
+      };
+      return v;
+    });
+  }
+  async getDeviceId() {
+    let result = await fetch(`${this.peerUrl}/configuration`);
+    const cfg = await result.json();
+    return cfg.agent_config.id;
+  }
+  async getConfiguration() {
+    let result = await fetch(`${this.peerUrl}/configuration`);
+    const cfg = await result.json();
+    return cfg.agent_config.document;
   }
   getRealtimeStatus() {
     if (this.rtcClient && this.remoteDevicePeerId) {
       return this.rtcClient.getConnectionStatus(this.remoteDevicePeerId);
     } else {
-      throw new Error(`Realtime connection hasn't been started for ${this.id}`);
+      throw new Error(`Realtime connection hasn't been started`);
     }
   }
   getRealtimePing() {
     if (this.rtcClient && this.remoteDevicePeerId) {
       return this.rtcClient.getPing(this.remoteDevicePeerId);
     } else {
-      throw new Error(`Realtime connection hasn't been started for ${this.id}`);
+      throw new Error(`Realtime connection hasn't been started`);
     }
   }
   async startRealtimeConnection(sessionType) {
     if (!this.rtcClient) {
-      let rtcClient;
-      if (rtcClientVersion === "1") {
-        rtcClient = new dist.exports.RtcClientV1({
-          signalingClient: new dist.exports.RtcSignalingClient(
-            FORMANT_API_URL + "/v1/signaling"
-          ),
-          getToken: async () => defined(
-            Authentication.token,
-            "Realtime when user isn't authorized"
-          ),
-          receive: this.handleMessage
-        });
-      } else {
-        rtcClient = new dist.exports.RtcClient({
-          signalingClient: new dist.exports.SignalingPromiseClient(
-            FORMANT_API_URL,
-            null,
-            null
-          ),
-          getToken: async () => {
-            return defined(
-              Authentication.token,
-              "Realtime when user isn't authorized"
-            );
-          },
-          receive: this.handleMessage,
-          sessionType
-        });
-      }
-      if (rtcClient.isReady) {
-        while (!rtcClient.isReady()) {
-          await delay(100);
-        }
-      }
-      const peers = await rtcClient.getPeers();
-      const devicePeer = peers.find((_) => _.deviceId === this.id);
-      if (!devicePeer) {
-        throw new Error("Cannot find peer, is the robot offline?");
-      }
-      this.remoteDevicePeerId = devicePeer.id;
-      await rtcClient.connect(this.remoteDevicePeerId);
-      while (rtcClient.getConnectionStatus(this.remoteDevicePeerId) !== "connected") {
+      const rtcClient = new dist.exports.RtcClient({
+        lanOnlyMode: true,
+        receive: this.handleMessage,
+        sessionType
+      });
+      await rtcClient.connectLan(this.peerUrl);
+      while (rtcClient.getConnectionStatus(this.peerUrl) !== "connected") {
         await delay(100);
       }
       this.rtcClient = rtcClient;
@@ -20006,16 +20192,6 @@ class Device {
       );
     }
   }
-  async sendRealtimeMessage(message, config = {
-    channelLabel: "stream.reliable"
-  }) {
-    const client = defined(
-      this.rtcClient,
-      "Realtime connection has not been started"
-    );
-    const devicePeer = await this.getRemotePeer();
-    client.send(defined(devicePeer).id, message, config);
-  }
   addRealtimeListener(listener) {
     this.realtimeListeners.push(listener);
   }
@@ -20024,54 +20200,27 @@ class Device {
     if (i === -1) {
       throw new Error("Could not find realtime listener to remove");
     }
-    this.realtimeListeners.splice(i, 1);
-  }
-  async getRealtimeAudioStreams() {
-    var _a, _b, _c, _d, _e, _f;
-    const document2 = await this.getConfiguration();
-    const streams = [];
-    for (const _ of (_b = (_a = document2.teleop) == null ? void 0 : _a.hardwareStreams) != null ? _b : []) {
-      if (_.rtcStreamType === "audio-chunk") {
-        streams.push({
-          name: _.name
-        });
-      }
-    }
-    for (const _ of (_d = (_c = document2.teleop) == null ? void 0 : _c.rosStreams) != null ? _d : []) {
-      if (_.topicType == "audio_common_msgs/AudioData") {
-        streams.push({
-          name: _.topicName
-        });
-      }
-    }
-    for (const _ of (_f = (_e = document2.teleop) == null ? void 0 : _e.customStreams) != null ? _f : []) {
-      if (_.rtcStreamType === "audio-chunk") {
-        streams.push({
-          name: _.name
-        });
-      }
-    }
-    return streams;
+    this.realtimeListeners.splice(i, 1);
   }
   async getRealtimeVideoStreams() {
-    var _a, _b, _c, _d, _e, _f;
+    var _a, _b, _c;
     const document2 = await this.getConfiguration();
     const streams = [];
-    for (const _ of (_b = (_a = document2.teleop) == null ? void 0 : _a.hardwareStreams) != null ? _b : []) {
+    for (const _ of (_a = document2.teleop.hardwareStreams) != null ? _a : []) {
       if (_.rtcStreamType === "h264-video-frame") {
         streams.push({
           name: _.name
         });
       }
     }
-    for (const _ of (_d = (_c = document2.teleop) == null ? void 0 : _c.rosStreams) != null ? _d : []) {
+    for (const _ of (_b = document2.teleop.rosStreams) != null ? _b : []) {
       if (_.topicType == "formant/H264VideoFrame") {
         streams.push({
           name: _.topicName
         });
       }
     }
-    for (const _ of (_f = (_e = document2.teleop) == null ? void 0 : _e.customStreams) != null ? _f : []) {
+    for (const _ of (_c = document2.teleop.customStreams) != null ? _c : []) {
       if (_.rtcStreamType === "h264-video-frame") {
         streams.push({
           name: _.name
@@ -20161,17 +20310,6 @@ class Device {
       pipeline: "telemetry"
     });
   }
-  async changeStreamAudioType(streamName, newFormat) {
-    const client = defined(
-      this.rtcClient,
-      "Realtime connection has not been started"
-    );
-    const devicePeer = await this.getRemotePeer();
-    client.controlRemoteStream(defined(devicePeer).id, {
-      streamName,
-      setAudioFormat: newFormat
-    });
-  }
   async disableRealtimeTelemetryPriorityIngestion(streamName) {
     const client = defined(
       this.rtcClient,
@@ -20185,15 +20323,13 @@ class Device {
     });
   }
   async getRemotePeer() {
-    const peers = await defined(
-      this.rtcClient,
-      "Realtime connection has not been started"
-    ).getPeers();
-    const devicePeer = peers.find((_) => _.deviceId === this.id);
-    return defined(
-      devicePeer,
-      "Could not find remote peer for device " + this.id
-    );
+    return {
+      id: this.peerUrl,
+      organizationId: "",
+      deviceId: this.id,
+      capabilities: [],
+      capabilitySet: {}
+    };
   }
   async stopRealtimeConnection() {
     if (this.rtcClient) {
@@ -20202,18 +20338,82 @@ class Device {
       throw new Error(`Realtime connection hasn't been started for ${this.id}`);
     }
   }
-  async isInRealtimeSession() {
-    let peers = await Fleet.getPeers();
-    let sessions = await Fleet.getRealtimeSessions();
-    let peer = peers.find((_) => _.deviceId === this.id);
-    if (peer) {
-      return sessions[peer.id].length > 0;
+  async createCustomDataChannel(channelName, rtcConfig) {
+    const client = defined(
+      this.rtcClient,
+      "Realtime connection has not been started"
+    );
+    const devicePeer = await this.getRemotePeer();
+    const p = await new Promise((resolve) => {
+      client.createCustomDataChannel(
+        defined(devicePeer).id,
+        channelName,
+        {
+          ordered: true,
+          ...rtcConfig
+        },
+        false,
+        (_peerId, channel) => {
+          const dataChannel = new DataChannel(channel);
+          resolve(dataChannel);
+        }
+      );
+    });
+    await p.waitTilReady();
+    return p;
+  }
+  createCustomRequestDataChannel(channelName, timeout = 3e3) {
+    return new TextRequestDataChannel(this, channelName, timeout);
+  }
+  createCustomBinaryRequestDataChannel(channelName, timeout = 3e3) {
+    return new BinaryRequestDataChannel(this, channelName, timeout);
+  }
+}
+const _Fleet$1 = class {
+  static async setDefaultDevice(deviceId) {
+    _Fleet$1.defaultDeviceId = deviceId;
+  }
+  static async getCurrentDevice() {
+    if (!Authentication.token) {
+      throw new Error("Not authenticated");
     }
-    return false;
+    if (!_Fleet$1.defaultDeviceId) {
+      throw new Error("No known default device");
+    }
+    const data = await fetch(
+      `${FORMANT_API_URL}/v1/admin/device-details/query`,
+      {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: "Bearer " + Authentication.token
+        }
+      }
+    );
+    const devices = await data.json();
+    const device = devices.items.find(
+      (_) => _.id === _Fleet$1.defaultDeviceId
+    );
+    const name = device.name;
+    const context = new Device(
+      _Fleet$1.defaultDeviceId,
+      name,
+      defined(Authentication.currentOrganization)
+    );
+    _Fleet$1.knownContext.push(new WeakRef(context));
+    return context;
   }
-  async getAvailableCommands() {
-    const result = await fetch(
-      `${FORMANT_API_URL}/v1/admin/command-templates/`,
+  static async getPeerDevice(url) {
+    const peer = new PeerDevice(url);
+    peer.id = await peer.getDeviceId();
+    return peer;
+  }
+  static async getDevice(deviceId) {
+    if (!Authentication.token) {
+      throw new Error("Not authenticated");
+    }
+    const data = await fetch(
+      `${FORMANT_API_URL}/v1/admin/devices/${deviceId}`,
       {
         method: "GET",
         headers: {
@@ -20222,440 +20422,868 @@ class Device {
         }
       }
     );
-    const commands = await result.json();
-    return commands.items.map((i) => ({
-      name: i.name,
-      id: i.id,
-      command: i.command,
-      description: i.description,
-      parameterEnabled: i.parameterEnabled,
-      parameterValue: i.parameterValue,
-      parameterMeta: i.parameterMeta,
-      enabled: i.enabled
-    }));
+    const device = await data.json();
+    const name = device.name;
+    const context = new Device(deviceId, name, device.organizationId);
+    _Fleet$1.knownContext.push(new WeakRef(context));
+    return context;
   }
-  async sendCommand(name, data, time, metadata) {
-    var _a;
-    const commands = await this.getAvailableCommands();
-    const command = commands.find((_) => _.name === name);
-    if (!command) {
-      throw new Error(`Could not find command with name "${name}"`);
+  static async getDevices() {
+    if (!Authentication.token) {
+      throw new Error("Not authenticated");
     }
-    let d;
-    if (data === void 0) {
-      if (command.parameterEnabled && command.parameterValue) {
-        d = command.parameterValue;
-      } else {
-        throw new Error(
-          "Command has no default parameter value, you must provide one"
+    const data = await fetch(
+      `${FORMANT_API_URL}/v1/admin/device-details/query`,
+      {
+        method: "POST",
+        body: JSON.stringify({ enabled: true, type: "default" }),
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: "Bearer " + Authentication.token
+        }
+      }
+    );
+    const devices = await data.json();
+    devices.items;
+    return devices.items.map(
+      (_) => new Device(_.id, _.name, _.organizationId)
+    );
+  }
+  static async queryDevices(query) {
+    if (!Authentication.token) {
+      throw new Error("Not authenticated");
+    }
+    const data = await fetch(`${FORMANT_API_URL}/v1/admin/devices/query`, {
+      method: "POST",
+      body: JSON.stringify(query),
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: "Bearer " + Authentication.token
+      }
+    });
+    const devices = await data.json();
+    return devices.items.map(
+      (_) => new Device(_.id, _.name, _.organizationId)
+    );
+  }
+  static async getOnlineDevices() {
+    if (!Authentication.token) {
+      throw new Error("Not authenticated");
+    }
+    const data = await fetch(`${FORMANT_API_URL}/v1/queries/online-devices`, {
+      method: "GET",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: "Bearer " + Authentication.token
+      }
+    });
+    const devices = await data.json();
+    const onlineIds = devices.items;
+    const allDevices = await _Fleet$1.getDevices();
+    return allDevices.filter((_) => onlineIds.includes(_.id));
+  }
+  static async getPeers() {
+    if (!Authentication.token) {
+      throw new Error("Not authenticated");
+    }
+    const rtcClient = new dist.exports.RtcClient({
+      signalingClient: new dist.exports.SignalingPromiseClient(FORMANT_API_URL, null, null),
+      getToken: async () => {
+        return defined(
+          Authentication.token,
+          "Realtime when user isn't authorized"
+        );
+      },
+      receive: () => {
+      }
+    });
+    return await rtcClient.getPeers();
+  }
+  static async getRealtimeSessions() {
+    if (!Authentication.token) {
+      throw new Error("Not authenticated");
+    }
+    const rtcClient = new dist.exports.RtcClient({
+      signalingClient: new dist.exports.SignalingPromiseClient(FORMANT_API_URL, null, null),
+      getToken: async () => {
+        return defined(
+          Authentication.token,
+          "Realtime when user isn't authorized"
         );
+      },
+      receive: () => {
+      }
+    });
+    return await rtcClient.getSessions();
+  }
+  static async getRealtimeDevices() {
+    if (!Authentication.token) {
+      throw new Error("Not authenticated");
+    }
+    const data = await fetch(`${FORMANT_API_URL}/v1/signaling/peers`, {
+      method: "GET",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: "Bearer " + Authentication.token
+      }
+    });
+    const devices = await data.json();
+    const onlineIds = devices.items.map(
+      (_) => _.deviceId
+    );
+    const allDevices = await _Fleet$1.getDevices();
+    return allDevices.filter((_) => onlineIds.includes(_.id));
+  }
+  static async getLatestTelemetry(deviceIdOrDeviceIds) {
+    let deviceIds = deviceIdOrDeviceIds;
+    if (deviceIdOrDeviceIds && !Array.isArray(deviceIdOrDeviceIds)) {
+      deviceIdOrDeviceIds = [deviceIdOrDeviceIds];
+    }
+    const data = await fetch(
+      `${FORMANT_API_URL}/v1/queries/stream-current-value`,
+      {
+        method: "POST",
+        body: JSON.stringify({
+          deviceIds
+        }),
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: "Bearer " + Authentication.token
+        }
       }
-    } else {
-      d = data;
+    );
+    const telemetry = await data.json();
+    return telemetry.items;
+  }
+  static async getTelemetry(deviceIdOrDeviceIds, streamNameOrStreamNames, start, end, tags) {
+    let deviceIds = deviceIdOrDeviceIds;
+    if (!Array.isArray(deviceIdOrDeviceIds)) {
+      deviceIds = [deviceIdOrDeviceIds];
     }
-    let parameter = {
-      value: d,
-      scrubberTime: (time || new Date()).toISOString(),
-      meta: {
-        ...command.parameterMeta,
-        ...metadata
+    let streamNames = streamNameOrStreamNames;
+    if (!Array.isArray(streamNameOrStreamNames)) {
+      streamNames = [streamNameOrStreamNames];
+    }
+    const data = await fetch(`${FORMANT_API_URL}/v1/queries/queries`, {
+      method: "POST",
+      body: JSON.stringify({
+        deviceIds,
+        end: end.toISOString(),
+        names: streamNames,
+        start: start.toISOString(),
+        tags
+      }),
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: "Bearer " + Authentication.token
       }
-    };
-    await fetch(`${FORMANT_API_URL}/v1/admin/commands`, {
+    });
+    const telemetry = await data.json();
+    return telemetry.items;
+  }
+  static async getFileUrl(uuid) {
+    const data = await fetch(`${FORMANT_API_URL}/v1/admin/files/query`, {
       method: "POST",
       body: JSON.stringify({
-        commandTemplateId: command.id,
-        organizationId: this.organizationId,
-        deviceId: this.id,
-        command: command.command,
-        parameter,
-        userId: (_a = Authentication.currentUser) == null ? void 0 : _a.id
+        fileIds: [uuid]
       }),
       headers: {
         "Content-Type": "application/json",
         Authorization: "Bearer " + Authentication.token
       }
     });
+    const result = await data.json();
+    if (result.fileUrls.length === 0) {
+      throw new Error("File not found");
+    }
+    return result.fileUrls[0];
   }
-  async createCustomDataChannel(channelName, rtcConfig) {
-    if (rtcClientVersion === "1") {
-      throw new Error(
-        "createCustomDataChannel is not supported in rtcClientVersion 1"
-      );
+  static async queryTelemetry(query) {
+    if (!Authentication.token) {
+      throw new Error("Not authenticated");
     }
-    const client = defined(
-      this.rtcClient,
-      "Realtime connection has not been started"
-    );
-    const devicePeer = await this.getRemotePeer();
-    const p = await new Promise((resolve) => {
-      client.createCustomDataChannel(
-        defined(devicePeer).id,
-        channelName,
-        {
-          ordered: true,
-          ...rtcConfig
-        },
-        false,
-        (_peerId, channel) => {
-          const dataChannel = new DataChannel(channel);
-          resolve(dataChannel);
-        }
-      );
+    const data = await fetch(`${FORMANT_API_URL}/v1/queries/queries`, {
+      method: "POST",
+      body: JSON.stringify(query),
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: "Bearer " + Authentication.token
+      }
     });
-    await p.waitTilReady();
-    return p;
-  }
-  createCustomRequestDataChannel(channelName, timeout = 3e3) {
-    return new TextRequestDataChannel(this, channelName, timeout);
+    return (await data.json()).items;
   }
-  createCustomBinaryRequestDataChannel(channelName, timeout = 3e3) {
-    return new BinaryRequestDataChannel(this, channelName, timeout);
+  static async aggregateTelemetry(query) {
+    if (!Authentication.token) {
+      throw new Error("Not authenticated");
+    }
+    const data = await fetch(`${FORMANT_API_URL}/v1/queries/queries`, {
+      method: "POST",
+      body: JSON.stringify(query),
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: "Bearer " + Authentication.token
+      }
+    });
+    return (await data.json()).aggregates;
   }
-  async createCaptureStream(streamName) {
-    const result = await fetch(`${FORMANT_API_URL}/v1/admin/capture-sessions`, {
+  static async queryEvents(query) {
+    if (!Authentication.token) {
+      throw new Error("Not authenticated");
+    }
+    const data = await fetch(`${FORMANT_API_URL}/v1/admin/events/query`, {
       method: "POST",
-      body: JSON.stringify({
-        deviceId: this.id,
-        streamName,
-        tags: {}
-      }),
+      body: JSON.stringify(query),
       headers: {
         "Content-Type": "application/json",
         Authorization: "Bearer " + Authentication.token
       }
     });
-    const captureSession = await result.json();
-    return new CaptureStream(captureSession);
+    return (await data.json()).items;
   }
-  async getTelemetry(streamNameOrStreamNames, start, end, tags) {
-    return await Fleet.getTelemetry(
-      this.id,
-      streamNameOrStreamNames,
-      start,
-      end,
-      tags
+  static async getEvent(uuid) {
+    if (!Authentication.token) {
+      throw new Error("Not authenticated");
+    }
+    const data = await fetch(
+      `${FORMANT_API_URL}/v1/admin/events/query/id=${uuid}`,
+      {
+        method: "GET",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: "Bearer " + Authentication.token
+        }
+      }
     );
+    return (await data.json()).items;
   }
-  async getTelemetryStreams() {
-    var _a, _b;
-    const config = await this.getConfiguration();
-    const result = await fetch(
-      `${FORMANT_API_URL}/v1/queries/metadata/stream-names`,
+  static async getInterventions() {
+    if (!Authentication.token) {
+      throw new Error("Not authenticated");
+    }
+    const interventions = await fetch(
+      `${FORMANT_API_URL}/v1/admin/intervention-requests`,
       {
-        method: "POST",
-        body: JSON.stringify({
-          deviceIds: [this.id]
-        }),
+        method: "GET",
         headers: {
           "Content-Type": "application/json",
           Authorization: "Bearer " + Authentication.token
         }
       }
     );
-    const disabledList = [];
-    const onDemandList = [];
-    (_b = (_a = config.telemetry) == null ? void 0 : _a.streams) == null ? void 0 : _b.forEach((_) => {
-      if (_.disabled !== true) {
-        disabledList.push(_.name);
+    return (await interventions.json()).items;
+  }
+  static async getCurrentGroup() {
+    if (!Authentication.token) {
+      throw new Error("Not authenticated");
+    }
+    let urlParams2 = new URLSearchParams("");
+    if (typeof window !== "undefined") {
+      urlParams2 = new URLSearchParams(window.location.search);
+    }
+    const groupId = urlParams2.get("group");
+    if (groupId === null || groupId.trim() === "") {
+      return void 0;
+    }
+    const response = await fetch(
+      `${FORMANT_API_URL}/v1/admin/groups/` + groupId,
+      {
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: "Bearer " + Authentication.token
+        }
       }
-      if (_.onDemand === true) {
-        onDemandList.push(_.name);
+    );
+    const { tagKey, tagValue } = await response.json();
+    const devices = await this.queryDevices({
+      tags: { [tagKey]: [tagValue] },
+      enabled: true,
+      type: "default"
+    });
+    return devices;
+  }
+};
+let Fleet$1 = _Fleet$1;
+__publicField(Fleet$1, "defaultDeviceId");
+__publicField(Fleet$1, "knownContext", []);
+function toInteger(dirtyNumber) {
+  if (dirtyNumber === null || dirtyNumber === true || dirtyNumber === false) {
+    return NaN;
+  }
+  var number = Number(dirtyNumber);
+  if (isNaN(number)) {
+    return number;
+  }
+  return number < 0 ? Math.ceil(number) : Math.floor(number);
+}
+function requiredArgs(required, args) {
+  if (args.length < required) {
+    throw new TypeError(required + " argument" + (required > 1 ? "s" : "") + " required, but only " + args.length + " present");
+  }
+}
+function _typeof(obj) {
+  "@babel/helpers - typeof";
+  if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
+    _typeof = function _typeof2(obj2) {
+      return typeof obj2;
+    };
+  } else {
+    _typeof = function _typeof2(obj2) {
+      return obj2 && typeof Symbol === "function" && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
+    };
+  }
+  return _typeof(obj);
+}
+function toDate(argument) {
+  requiredArgs(1, arguments);
+  var argStr = Object.prototype.toString.call(argument);
+  if (argument instanceof Date || _typeof(argument) === "object" && argStr === "[object Date]") {
+    return new Date(argument.getTime());
+  } else if (typeof argument === "number" || argStr === "[object Number]") {
+    return new Date(argument);
+  } else {
+    if ((typeof argument === "string" || argStr === "[object String]") && typeof console !== "undefined") {
+      console.warn("Starting with v2.0.0-beta.1 date-fns doesn't accept strings as date arguments. Please use `parseISO` to parse strings. See: https://github.com/date-fns/date-fns/blob/master/docs/upgradeGuide.md#string-arguments");
+      console.warn(new Error().stack);
+    }
+    return new Date(NaN);
+  }
+}
+function addMilliseconds(dirtyDate, dirtyAmount) {
+  requiredArgs(2, arguments);
+  var timestamp = toDate(dirtyDate).getTime();
+  var amount = toInteger(dirtyAmount);
+  return new Date(timestamp + amount);
+}
+var MILLISECONDS_IN_MINUTE = 6e4;
+function addMinutes(dirtyDate, dirtyAmount) {
+  requiredArgs(2, arguments);
+  var amount = toInteger(dirtyAmount);
+  return addMilliseconds(dirtyDate, amount * MILLISECONDS_IN_MINUTE);
+}
+function addSeconds(dirtyDate, dirtyAmount) {
+  requiredArgs(2, arguments);
+  var amount = toInteger(dirtyAmount);
+  return addMilliseconds(dirtyDate, amount * 1e3);
+}
+var roundingMap = {
+  ceil: Math.ceil,
+  round: Math.round,
+  floor: Math.floor,
+  trunc: function trunc(value) {
+    return value < 0 ? Math.ceil(value) : Math.floor(value);
+  }
+};
+var defaultRoundingMethod = "trunc";
+function getRoundingMethod(method) {
+  return method ? roundingMap[method] : roundingMap[defaultRoundingMethod];
+}
+function startOfMinute(dirtyDate) {
+  requiredArgs(1, arguments);
+  var date = toDate(dirtyDate);
+  date.setSeconds(0, 0);
+  return date;
+}
+function roundToNearestMinutes(dirtyDate, options) {
+  var _options$nearestTo;
+  if (arguments.length < 1) {
+    throw new TypeError("1 argument required, but only none provided present");
+  }
+  var nearestTo = toInteger((_options$nearestTo = options === null || options === void 0 ? void 0 : options.nearestTo) !== null && _options$nearestTo !== void 0 ? _options$nearestTo : 1);
+  if (nearestTo < 1 || nearestTo > 30) {
+    throw new RangeError("`options.nearestTo` must be between 1 and 30");
+  }
+  var date = toDate(dirtyDate);
+  var seconds = date.getSeconds();
+  var minutes = date.getMinutes() + seconds / 60;
+  var roundingMethod = getRoundingMethod(options === null || options === void 0 ? void 0 : options.roundingMethod);
+  var roundedMinutes = roundingMethod(minutes / nearestTo) * nearestTo;
+  var remainderMinutes = minutes % nearestTo;
+  var addedMinutes = Math.round(remainderMinutes / nearestTo) * nearestTo;
+  return new Date(date.getFullYear(), date.getMonth(), date.getDate(), date.getHours(), roundedMinutes + addedMinutes);
+}
+const millisecond = 1;
+const second = 1e3;
+const minute = 60 * second;
+const hour = 60 * minute;
+const day = 24 * hour;
+const week = 7 * day;
+const month = 30 * day;
+const year = 365 * day;
+const duration = {
+  millisecond,
+  second,
+  minute,
+  hour,
+  day,
+  week,
+  month,
+  year
+};
+function filterDataByType(datas, type) {
+  return datas.filter((_) => _.type === type);
+}
+function filterDataByTime(datas, start, end) {
+  const startTime = start.getTime();
+  const endTime = end.getTime();
+  return datas.map((data) => ({
+    ...data,
+    points: data.points.filter(
+      ([timestamp]) => timestamp >= startTime && timestamp < endTime
+    )
+  })).filter(({ points }) => points.length > 0);
+}
+function fork(_) {
+  return void 0;
+}
+class StoreCache {
+  constructor({
+    capacity,
+    timeout
+  } = {}) {
+    __publicField(this, "entries", /* @__PURE__ */ new Map());
+    __publicField(this, "metadata", /* @__PURE__ */ new Map());
+    __publicField(this, "capacity");
+    __publicField(this, "timeout");
+    this.capacity = capacity || 1e4;
+    this.timeout = timeout || duration.minute;
+  }
+  get(key, generator) {
+    const cacheKey = this.keyToCacheKey(key);
+    const entry = this.entries.get(cacheKey);
+    const metadata = this.metadata.get(cacheKey);
+    if ((entry === void 0 || metadata && (metadata == null ? void 0 : metadata.expiration.getTime()) < Date.now()) && !(metadata == null ? void 0 : metadata.generating) && generator) {
+      this.generate(key, generator());
+    }
+    if (entry === void 0 && metadata && metadata.lastValue !== void 0) {
+      return metadata.lastValue;
+    }
+    return entry;
+  }
+  set(key, value) {
+    const cacheKey = this.keyToCacheKey(key);
+    this.metadata.set(cacheKey, {
+      generating: false,
+      expiration: new Date(Date.now() + this.timeout),
+      lastValue: value
+    });
+    this.entries.set(cacheKey, value);
+    if (this.metadata.size > this.capacity) {
+      this.deleteOldestEntry();
+    }
+  }
+  clear() {
+    this.entries.clear();
+    [...this.metadata.values()].forEach((value) => value.generating = false);
+  }
+  clearKey(key) {
+    this.metadata.delete(key);
+    this.entries.delete(key);
+  }
+  keyToCacheKey(key) {
+    return JSON.stringify(key);
+  }
+  deleteOldestEntry() {
+    if (this.metadata.size < 1) {
+      return;
+    }
+    const [key] = [...this.metadata.entries()].reduce(
+      ([oldestKey, oldestEntry], [thisKey, entry]) => entry.expiration.getTime() < oldestEntry.expiration.getTime() ? [thisKey, entry] : [oldestKey, oldestEntry]
+    );
+    this.clearKey(key);
+  }
+  generate(key, promise) {
+    const cacheKey = this.keyToCacheKey(key);
+    const existingMetadata = this.metadata.get(cacheKey) || {};
+    this.metadata.set(cacheKey, {
+      ...existingMetadata,
+      generating: true,
+      expiration: new Date(Date.now() + this.timeout)
+    });
+    setTimeout(() => {
+      fork(
+        promise.then((value) => {
+          const metadata = this.metadata.get(cacheKey);
+          const canceled = !(metadata == null ? void 0 : metadata.generating);
+          if (!canceled) {
+            this.set(key, value);
+          }
+        })
+      );
+    }, 0);
+  }
+}
+class QueryStore {
+  constructor() {
+    __publicField(this, "queryStoreCache", new StoreCache({
+      capacity: 1e4,
+      timeout: 20 * duration.second
+    }));
+    __publicField(this, "liveQueryStoreCache", new StoreCache({
+      capacity: 1e4,
+      timeout: 200 * duration.millisecond
+    }));
+  }
+  moduleQuery(filter, name, type, start, end, latestOnly = false) {
+    const q = {
+      ...filter,
+      names: [name],
+      types: [type]
+    };
+    const data = this.query(q, start, end, latestOnly);
+    if (data === void 0 || data === "too much data") {
+      return data;
+    }
+    return filterDataByType(data, type);
+  }
+  query(filter, start, end, latestOnly = false) {
+    const q = {
+      ...filter,
+      start: startOfMinute(start).toISOString(),
+      end: latestOnly ? end.toISOString() : addMinutes(roundToNearestMinutes(end), 1).toISOString(),
+      latestOnly
+    };
+    const isLive = end > addSeconds(new Date(), -20);
+    let data;
+    if (isLive) {
+      data = this.liveQueryCache(q);
+    } else {
+      data = this.queryCache(q);
+    }
+    if (!data || data === "too much data") {
+      return data;
+    }
+    if (latestOnly) {
+      return data;
+    }
+    return filterDataByTime(data, start, end);
+  }
+  queryCache(query) {
+    return this.queryStoreCache.get(query, async () => {
+      try {
+        return await Fleet$1.queryTelemetry(query);
+      } catch (error) {
+        throw error;
       }
     });
-    console.log(onDemandList);
-    const data = await result.json();
-    let streamNames = data.items.filter((_) => !disabledList.includes(_)).map((_) => ({ name: _, onDemand: onDemandList.includes(_) }));
-    return streamNames;
   }
-  async createInterventionRequest(message, interventionType, interventionRequest, tags) {
-    const intervention = await fetch(
-      `${FORMANT_API_URL}/v1/admin/intervention-requests`,
-      {
-        method: "POST",
-        body: JSON.stringify({
-          message,
-          interventionType,
-          time: new Date().toISOString(),
-          deviceId: this.id,
-          tags,
-          data: interventionRequest
-        }),
-        headers: {
-          "Content-Type": "application/json",
-          Authorization: "Bearer " + Authentication.token
-        }
+  liveQueryCache(query) {
+    return this.liveQueryStoreCache.get(query, async () => {
+      try {
+        return await Fleet$1.queryTelemetry(query);
+      } catch (error) {
+        throw error;
       }
-    );
-    const interventionJson = await intervention.json();
-    return interventionJson;
+    });
   }
-  async addInterventionResponse(interventionId, interventionType, data) {
+}
+const queryStore = new QueryStore();
+class App {
+  static sendAppMessage(message) {
+    window.parent.postMessage(message, "*");
+  }
+  static getCurrentModuleContext() {
+    let urlParams2 = new URLSearchParams("");
+    if (typeof window !== "undefined") {
+      urlParams2 = new URLSearchParams(window.location.search);
+    }
+    const moduleName2 = urlParams2.get("module");
+    return moduleName2;
+  }
+  static async getCurrentModuleConfiguration() {
+    let urlParams2 = new URLSearchParams("");
+    if (typeof window !== "undefined") {
+      urlParams2 = new URLSearchParams(window.location.search);
+    }
+    const configurationId = urlParams2.get("configuration");
+    if (configurationId === null || configurationId.trim() === "") {
+      return void 0;
+    }
     const response = await fetch(
-      `${FORMANT_API_URL}/v1/admin/intervention-responses`,
+      `${FORMANT_API_URL}/v1/admin/module-configurations/` + configurationId,
       {
-        method: "POST",
-        body: JSON.stringify({
-          interventionId,
-          interventionType,
-          data
-        }),
         headers: {
           "Content-Type": "application/json",
           Authorization: "Bearer " + Authentication.token
         }
       }
     );
-    const interventionResponse = await response.json();
-    return interventionResponse;
+    const moduleConfiguration = await response.json();
+    return moduleConfiguration.configuration;
   }
-}
-class PeerDevice {
-  constructor(peerUrl) {
-    __publicField(this, "rtcClient");
-    __publicField(this, "remoteDevicePeerId");
-    __publicField(this, "realtimeListeners", []);
-    __publicField(this, "id");
-    __publicField(this, "handleMessage", (peerId, message) => {
-      this.realtimeListeners.forEach((_) => _(peerId, message));
-    });
-    this.peerUrl = peerUrl;
+  static isModule() {
+    return this.getCurrentModuleContext() !== null;
   }
-  async getLatestTelemetry() {
-    const data = await fetch(`${this.peerUrl}/telemetry`);
-    const telemetry = await data.json();
-    const entries = Object.entries(telemetry);
-    return entries.map(([stream, latestValue]) => {
-      const v = {
-        deviceId: this.id,
-        streamName: stream,
-        streamType: "json",
-        currentValue: latestValue,
-        currentValueTime: latestValue.timestamp,
-        tags: {}
-      };
-      return v;
+  static goToTime(date) {
+    this.sendAppMessage({
+      type: "go_to_time",
+      time: date.getTime()
     });
   }
-  async getDeviceId() {
-    let result = await fetch(`${this.peerUrl}/configuration`);
-    const cfg = await result.json();
-    return cfg.agent_config.id;
+  static goToDevice(deviceId) {
+    this.sendAppMessage({
+      type: "go_to_device",
+      deviceId
+    });
   }
-  async getConfiguration() {
-    let result = await fetch(`${this.peerUrl}/configuration`);
-    const cfg = await result.json();
-    return cfg.agent_config.document;
+  static showMessage(message) {
+    this.sendAppMessage({ type: "show_message", message });
   }
-  getRealtimeStatus() {
-    if (this.rtcClient && this.remoteDevicePeerId) {
-      return this.rtcClient.getConnectionStatus(this.remoteDevicePeerId);
-    } else {
-      throw new Error(`Realtime connection hasn't been started`);
+  static requestModuleData() {
+    const moduleName2 = this.getCurrentModuleContext();
+    if (!moduleName2) {
+      throw new Error("No module context");
     }
+    this.sendAppMessage({
+      type: "request_module_data",
+      module: moduleName2
+    });
   }
-  getRealtimePing() {
-    if (this.rtcClient && this.remoteDevicePeerId) {
-      return this.rtcClient.getPing(this.remoteDevicePeerId);
-    } else {
-      throw new Error(`Realtime connection hasn't been started`);
+  static setModuleDateTimeRange(beforeInMilliseconds, afterInMilliseconds) {
+    const moduleName2 = this.getCurrentModuleContext();
+    if (!moduleName2) {
+      throw new Error("No module context");
     }
+    this.sendAppMessage({
+      type: "set_module_data_time_range",
+      module: moduleName2,
+      before: beforeInMilliseconds,
+      after: afterInMilliseconds || 0
+    });
   }
-  async startRealtimeConnection(sessionType) {
-    if (!this.rtcClient) {
-      const rtcClient = new dist.exports.RtcClient({
-        lanOnlyMode: true,
-        receive: this.handleMessage,
-        sessionType
-      });
-      await rtcClient.connectLan(this.peerUrl);
-      while (rtcClient.getConnectionStatus(this.peerUrl) !== "connected") {
-        await delay(100);
-      }
-      this.rtcClient = rtcClient;
-    } else {
-      throw new Error(
-        `Already created realtime connection to device ${this.id}`
-      );
+  static refreshAuthToken() {
+    const moduleName2 = this.getCurrentModuleContext();
+    if (!moduleName2) {
+      throw new Error("No module context");
     }
+    this.sendAppMessage({
+      type: "refresh_auth_token",
+      module: moduleName2
+    });
   }
-  addRealtimeListener(listener) {
-    this.realtimeListeners.push(listener);
-  }
-  removeRealtimeListener(listener) {
-    const i = this.realtimeListeners.indexOf(listener);
-    if (i === -1) {
-      throw new Error("Could not find realtime listener to remove");
+  static sendChannelData(channel, data) {
+    const moduleName2 = this.getCurrentModuleContext();
+    if (!moduleName2) {
+      throw new Error("No module context");
     }
-    this.realtimeListeners.splice(i, 1);
+    this.sendAppMessage({
+      type: "send_channel_data",
+      source: moduleName2,
+      channel,
+      data
+    });
   }
-  async getRealtimeVideoStreams() {
-    var _a, _b, _c;
-    const document2 = await this.getConfiguration();
-    const streams = [];
-    for (const _ of (_a = document2.teleop.hardwareStreams) != null ? _a : []) {
-      if (_.rtcStreamType === "h264-video-frame") {
-        streams.push({
-          name: _.name
-        });
-      }
+  static setupModuleMenus(menus) {
+    const moduleName2 = this.getCurrentModuleContext();
+    if (!moduleName2) {
+      throw new Error("No module context");
     }
-    for (const _ of (_b = document2.teleop.rosStreams) != null ? _b : []) {
-      if (_.topicType == "formant/H264VideoFrame") {
-        streams.push({
-          name: _.topicName
-        });
+    this.sendAppMessage({
+      type: "setup_module_menus",
+      module: moduleName2,
+      menus
+    });
+  }
+  static addMenuListener(handler) {
+    window.addEventListener("message", (event) => {
+      const msg = event.data;
+      if (msg.type === "module_menu_item_clicked") {
+        handler(msg.menu);
       }
-    }
-    for (const _ of (_c = document2.teleop.customStreams) != null ? _c : []) {
-      if (_.rtcStreamType === "h264-video-frame") {
-        streams.push({
-          name: _.name
-        });
+    });
+  }
+  static addAccessTokenRefreshListener(handler) {
+    window.addEventListener("message", (event) => {
+      const msg = event.data;
+      if (msg.type === "auth_token") {
+        handler(msg.token);
       }
-    }
-    return streams;
+    });
   }
-  async getRealtimeManipulators() {
-    var _a;
-    const document2 = await this.getConfiguration();
-    const manipulators = [];
-    for (const _ of (_a = document2.teleop.rosStreams) != null ? _a : []) {
-      if (_.topicType == "sensor_msgs/JointState") {
-        manipulators.push(
-          new Manipulator(this, {
-            currentJointStateStream: { name: _.topicName },
-            plannedJointStateStream: _.plannedTopic ? { name: _.plannedTopic } : void 0,
-            planValidStream: _.planValidTopic ? { name: _.planValidTopic } : void 0,
-            endEffectorStream: _.endEffectorTopic ? { name: _.endEffectorTopic } : void 0,
-            endEffectorLinkName: _.endEffectorLinkName,
-            baseReferenceFrame: _.baseReferenceFrame,
-            localFrame: _.localFrame
-          })
+  static addModuleDataListener(handler) {
+    const moduleName2 = this.getCurrentModuleContext();
+    if (moduleName2) {
+      this.sendAppMessage({ type: "request_module_data", module: moduleName2 });
+    }
+    window.addEventListener("message", (event) => {
+      const msg = event.data;
+      if (msg.type === "module_data") {
+        handler({
+          streams: msg.streams,
+          time: msg.time,
+          queryRange: msg.queryRange
+        });
+      }
+    });
+  }
+  static addStreamListener(streamName, streamType, handler) {
+    const listener = (event) => {
+      const msg = event.data;
+      if (msg.type === "module_data") {
+        const { start, end } = msg.queryRange;
+        handler(
+          queryStore.moduleQuery(
+            {},
+            streamName,
+            streamType,
+            new Date(start),
+            new Date(end),
+            false
+          )
         );
       }
-    }
-    return manipulators;
+    };
+    window.addEventListener("message", listener);
+    return () => window.removeEventListener("message", listener);
   }
-  async startListeningToRealtimeVideo(stream) {
-    const client = defined(
-      this.rtcClient,
-      "Realtime connection has not been started"
-    );
-    const devicePeer = await this.getRemotePeer();
-    client.controlRemoteStream(defined(devicePeer).id, {
-      streamName: stream.name,
-      enable: true,
-      pipeline: "rtc"
+  static addModuleConfigurationListener(handler) {
+    window.addEventListener("message", (event) => {
+      const msg = event.data;
+      if (msg.type === "module_configuration") {
+        handler(msg);
+      }
     });
   }
-  async stopListeningToRealtimeVideo(stream) {
-    const client = defined(
-      this.rtcClient,
-      "Realtime connection has not been started"
-    );
-    const devicePeer = await this.getRemotePeer();
-    client.controlRemoteStream(defined(devicePeer).id, {
-      streamName: stream.name,
-      enable: false,
-      pipeline: "rtc"
+  static addChannelDataListener(channel, handler) {
+    window.addEventListener("message", (event) => {
+      const msg = event.data;
+      if (msg.type === "channel_data" && msg.channel === channel) {
+        handler({
+          source: msg.source,
+          data: msg.data
+        });
+      }
     });
   }
-  async startListeningToRealtimeDataStream(stream) {
-    const client = defined(
-      this.rtcClient,
-      "Realtime connection has not been started"
-    );
-    const devicePeer = await this.getRemotePeer();
-    client.controlRemoteStream(defined(devicePeer).id, {
-      streamName: stream.name,
-      enable: true,
-      pipeline: "rtc"
+  static requestOverviewDevices(handler) {
+    this.sendAppMessage({ type: "request_devices" });
+    window.addEventListener("message", (event) => {
+      const msg = event.data;
+      handler(msg);
     });
   }
-  async stopListeningToRealtimeDataStream(stream) {
-    const client = defined(
-      this.rtcClient,
-      "Realtime connection has not been started"
-    );
-    const devicePeer = await this.getRemotePeer();
-    client.controlRemoteStream(defined(devicePeer).id, {
-      streamName: stream.name,
-      enable: false,
-      pipeline: "rtc"
-    });
+}
+const _Authentication = class {
+  static async login(email, password) {
+    try {
+      const result = await fetch(`${FORMANT_API_URL}/v1/admin/auth/login`, {
+        method: "POST",
+        body: JSON.stringify({ email, password }),
+        headers: {
+          "Content-Type": "application/json"
+        }
+      });
+      const auth = await result.json();
+      if (result.status !== 200) {
+        throw new Error(auth.message);
+      }
+      await _Authentication.loginWithToken(
+        auth.authentication.accessToken,
+        auth.authentication.refreshToken
+      );
+      return auth.authentication;
+    } catch (e) {
+      _Authentication.waitingForAuth.forEach((_) => _(false));
+      _Authentication.waitingForAuth = [];
+      return Promise.reject(e);
+    }
   }
-  async enableRealtimeTelemetryPriorityIngestion(streamName) {
-    const client = defined(
-      this.rtcClient,
-      "Realtime connection has not been started"
-    );
-    const devicePeer = await this.getRemotePeer();
-    client.controlRemoteStream(defined(devicePeer).id, {
-      streamName,
-      enablePriorityUpload: true,
-      pipeline: "telemetry"
-    });
+  static async loginWithToken(token, refreshToken) {
+    const tokenData = JSON.parse(atob(token.split(".")[1]));
+    try {
+      let userId;
+      _Authentication.isShareToken = tokenData["formant:claims"] && tokenData["formant:claims"].type == "share";
+      if (tokenData["formant:claims"]) {
+        _Authentication.currentOrganization = tokenData["formant:claims"].organizationId;
+      }
+      if (tokenData["custom:organization_id"]) {
+        _Authentication.currentOrganization = tokenData["custom:organization_id"];
+      }
+      if (!_Authentication.isShareToken) {
+        userId = tokenData.sub;
+      }
+      if (tokenData["formant:claims"] && tokenData["formant:claims"].userId) {
+        userId = tokenData["formant:claims"].userId;
+      }
+      if (userId) {
+        const result = await fetch(
+          `${FORMANT_API_URL}/v1/admin/users/${userId}`,
+          {
+            method: "GET",
+            headers: {
+              "Content-Type": "application/json",
+              Authorization: "Bearer " + token
+            }
+          }
+        );
+        const data = await result.json();
+        if (result.status !== 200) {
+          throw new Error(data.message);
+        }
+        _Authentication.currentUser = data;
+      }
+      _Authentication.token = token;
+      _Authentication.waitingForAuth.forEach((_) => _(true));
+    } catch (e) {
+      console.error(e);
+      _Authentication.waitingForAuth.forEach((_) => _(false));
+    }
+    _Authentication.waitingForAuth = [];
+    if (refreshToken) {
+      _Authentication.refreshToken = refreshToken;
+      setInterval(async () => {
+        if (_Authentication.refreshToken) {
+          const result = await fetch(
+            `${FORMANT_API_URL}/v1/admin/auth/refresh`,
+            {
+              method: "POST",
+              headers: {
+                "Content-Type": "application/json"
+              },
+              body: JSON.stringify({
+                refreshToken: _Authentication.refreshToken
+              })
+            }
+          );
+          const refreshData = await result.json();
+          _Authentication.token = refreshData.authentication.accessToken;
+        }
+      }, 1e3 * 60 * 60);
+    }
   }
-  async disableRealtimeTelemetryPriorityIngestion(streamName) {
-    const client = defined(
-      this.rtcClient,
-      "Realtime connection has not been started"
-    );
-    const devicePeer = await this.getRemotePeer();
-    client.controlRemoteStream(defined(devicePeer).id, {
-      streamName,
-      enablePriorityUpload: false,
-      pipeline: "telemetry"
-    });
+  static isAuthenticated() {
+    return _Authentication.token !== void 0;
   }
-  async getRemotePeer() {
-    return {
-      id: this.peerUrl,
-      organizationId: "",
-      deviceId: this.id,
-      capabilities: [],
-      capabilitySet: {}
-    };
+  static getCurrentUser() {
+    return _Authentication.currentUser;
   }
-  async stopRealtimeConnection() {
-    if (this.rtcClient) {
-      await this.rtcClient.disconnect(this.id);
+  static async waitTilAuthenticated() {
+    if (_Authentication.token !== void 0) {
+      return true;
     } else {
-      throw new Error(`Realtime connection hasn't been started for ${this.id}`);
+      return new Promise((resolve) => {
+        _Authentication.waitingForAuth.push(function(result) {
+          resolve(result);
+        });
+      });
     }
   }
-  async createCustomDataChannel(channelName, rtcConfig) {
-    const client = defined(
-      this.rtcClient,
-      "Realtime connection has not been started"
-    );
-    const devicePeer = await this.getRemotePeer();
-    const p = await new Promise((resolve) => {
-      client.createCustomDataChannel(
-        defined(devicePeer).id,
-        channelName,
-        {
-          ordered: true,
-          ...rtcConfig
-        },
-        false,
-        (_peerId, channel) => {
-          const dataChannel = new DataChannel(channel);
-          resolve(dataChannel);
-        }
-      );
+  static async listenForRefresh() {
+    App.addAccessTokenRefreshListener((token) => {
+      this.loginWithToken(token);
     });
-    await p.waitTilReady();
-    return p;
-  }
-  createCustomRequestDataChannel(channelName, timeout = 3e3) {
-    return new TextRequestDataChannel(this, channelName, timeout);
-  }
-  createCustomBinaryRequestDataChannel(channelName, timeout = 3e3) {
-    return new BinaryRequestDataChannel(this, channelName, timeout);
+    setInterval(async () => {
+      App.refreshAuthToken();
+    }, 1e3 * 60 * 60);
   }
-}
+};
+let Authentication = _Authentication;
+__publicField(Authentication, "token");
+__publicField(Authentication, "refreshToken");
+__publicField(Authentication, "currentUser");
+__publicField(Authentication, "currentOrganization");
+__publicField(Authentication, "isShareToken", false);
+__publicField(Authentication, "defaultDeviceId");
+__publicField(Authentication, "waitingForAuth", []);
 const _Fleet = class {
   static async setDefaultDevice(deviceId) {
     _Fleet.defaultDeviceId = deviceId;
@@ -21159,9 +21787,6 @@ function combineNumericSetAggregates(e1, e2) {
 function stringToArrayBuffer(input) {
   return Uint8Array.from(atob(input), (_) => _.charCodeAt(0));
 }
-function fork(_) {
-  return void 0;
-}
 function browser() {
   const { userAgent } = navigator;
   if (userAgent.includes("Firefox/")) {