@formant/data-sdk 0.0.129 → 0.0.130

package/dist/data-sdk.es.js

@@ -19231,1321 +19231,879 @@ const envLocal = urlParams$2.get("formant_local");
 if (envLocal) {
   FORMANT_API_URL = "https://api.formant.local";
 }
-function delay(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
+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);
 }
-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);
+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;
   }
-  removeOpenListener(listener) {
-    this.openListeners = this.openListeners.filter((_) => _ !== listener);
+  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;
   }
-  addCloseListener(listener) {
-    this.closeListeners.push(listener);
+  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();
+    }
   }
-  removeCloseListener(listener) {
-    this.closeListeners = this.closeListeners.filter((l) => l !== listener);
+  clear() {
+    this.entries.clear();
+    [...this.metadata.values()].forEach((value) => value.generating = false);
   }
-  addErrorListener(listener) {
-    this.errorListeners.push(listener);
+  clearKey(key) {
+    this.metadata.delete(key);
+    this.entries.delete(key);
   }
-  removeErrorListener(listener) {
-    this.errorListeners = this.errorListeners.filter((l) => l !== listener);
+  keyToCacheKey(key) {
+    return JSON.stringify(key);
   }
-  async waitTilReady() {
-    if (this.ready) {
-      return true;
+  deleteOldestEntry() {
+    if (this.metadata.size < 1) {
+      return;
     }
-    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);
+    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)
     });
-    return p;
+    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);
   }
-  send(data) {
-    if (!this.ready) {
-      throw new Error("Connection has been closed");
-    }
-    this.dataChannel.send(data);
+}
+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
+    }));
   }
-  sendBinary(data) {
-    if (!this.ready) {
-      throw new Error("Connection has been closed");
+  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;
     }
-    this.dataChannel.send(data);
-  }
-  addListener(listener) {
-    this.listeners.push(listener);
+    return filterDataByType(data, type);
   }
-  removeListener(listener) {
-    const i = this.listeners.indexOf(listener);
-    if (i === -1) {
-      throw new Error("Could not find data channel listener to remove");
+  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 (this.error) {
-      throw new Error(this.error);
+    if (!data || data === "too much data") {
+      return data;
     }
-    this.listeners.splice(i, 1);
+    if (latestOnly) {
+      return data;
+    }
+    return filterDataByTime(data, start, end);
   }
-  addBinaryListener(listener) {
-    this.binaryListeners.push(listener);
+  queryCache(query) {
+    return this.queryStoreCache.get(query, async () => {
+      try {
+        return await Fleet.queryTelemetry(query);
+      } catch (error) {
+        throw error;
+      }
+    });
   }
-  removeBinaryListener(listener) {
-    const i = this.binaryListeners.indexOf(listener);
-    if (i === -1) {
-      throw new Error("Could not find data channel listener to remove");
-    }
-    if (this.error) {
-      throw new Error(this.error);
-    }
-    this.binaryListeners.splice(i, 1);
+  liveQueryCache(query) {
+    return this.liveQueryStoreCache.get(query, async () => {
+      try {
+        return await Fleet.queryTelemetry(query);
+      } catch (error) {
+        throw error;
+      }
+    });
   }
 }
-class CaptureStream {
-  constructor(captureSession) {
-    __publicField(this, "token");
-    this.captureSession = captureSession;
+const queryStore = new QueryStore();
+class App {
+  static sendAppMessage(message) {
+    window.parent.postMessage(message, "*");
   }
-  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;
+  static getCurrentModuleContext() {
+    let urlParams2 = new URLSearchParams("");
+    if (typeof window !== "undefined") {
+      urlParams2 = new URLSearchParams(window.location.search);
     }
-    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
-      }
-    });
+    const moduleName2 = urlParams2.get("module");
+    return moduleName2;
   }
-}
-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);
-        });
+  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
+        }
       }
-    });
-    this.device = device;
-    this.config = config;
-  }
-  async synchronize() {
-    this.device.addRealtimeListener(this.onRealtimeMessage);
-    this.device.startListeningToRealtimeDataStream(
-      this.config.currentJointStateStream
-    );
-  }
-  async desynchronize() {
-    this.device.removeRealtimeListener(this.onRealtimeMessage);
-    this.device.stopListeningToRealtimeDataStream(
-      this.config.currentJointStateStream
     );
+    const moduleConfiguration = await response.json();
+    return moduleConfiguration.configuration;
   }
-  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;
+  static isModule() {
+    return this.getCurrentModuleContext() !== null;
   }
-  addOpenListener(listener) {
-    defined(this.channel, "channel not initalized").addOpenListener(listener);
+  static goToTime(date) {
+    this.sendAppMessage({
+      type: "go_to_time",
+      time: date.getTime()
+    });
   }
-  removeOpenListener(listener) {
-    defined(this.channel, "channel not initalized").removeOpenListener(
-      listener
-    );
+  static goToDevice(deviceId) {
+    this.sendAppMessage({
+      type: "go_to_device",
+      deviceId
+    });
   }
-  addCloseListener(listener) {
-    defined(this.channel, "channel not initalized").addCloseListener(listener);
+  static showMessage(message) {
+    this.sendAppMessage({ type: "show_message", message });
   }
-  removeCloseListener(listener) {
-    defined(this.channel, "channel not initalized").removeCloseListener(
-      listener
-    );
+  static requestModuleData() {
+    const moduleName2 = this.getCurrentModuleContext();
+    if (!moduleName2) {
+      throw new Error("No module context");
+    }
+    this.sendAppMessage({
+      type: "request_module_data",
+      module: moduleName2
+    });
   }
-  addErrorListener(listener) {
-    defined(this.channel, "channel not initalized").addErrorListener(listener);
+  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
+    });
   }
-  removeErrorListener(listener) {
-    defined(this.channel, "channel not initalized").removeErrorListener(
-      listener
-    );
+  static refreshAuthToken() {
+    const moduleName2 = this.getCurrentModuleContext();
+    if (!moduleName2) {
+      throw new Error("No module context");
+    }
+    this.sendAppMessage({
+      type: "refresh_auth_token",
+      module: moduleName2
+    });
   }
-}
-class BinaryRequestDataChannel extends RequestDataChannel {
-  constructor() {
-    super(...arguments);
-    __publicField(this, "RESPONSE_SUCCESS_BYTE", 0);
-    __publicField(this, "decoder", new TextDecoder());
+  static sendChannelData(channel, data) {
+    const moduleName2 = this.getCurrentModuleContext();
+    if (!moduleName2) {
+      throw new Error("No module context");
+    }
+    this.sendAppMessage({
+      type: "send_channel_data",
+      source: moduleName2,
+      channel,
+      data
+    });
   }
-  generateBinaryId() {
-    const id = new Uint8Array(16);
-    for (let i = 0; i < id.length; i++) {
-      id[i] = Math.floor(Math.random() * 256);
+  static setupModuleMenus(menus) {
+    const moduleName2 = this.getCurrentModuleContext();
+    if (!moduleName2) {
+      throw new Error("No module context");
     }
-    return id;
+    this.sendAppMessage({
+      type: "setup_module_menus",
+      module: moduleName2,
+      menus
+    });
   }
-  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");
+  static addMenuListener(handler) {
+    window.addEventListener("message", (event) => {
+      const msg = event.data;
+      if (msg.type === "module_menu_item_clicked") {
+        handler(msg.menu);
       }
-      if (this.requestIdToResponseMap.has(id)) {
-        this.requestIdToResponseMap.set(id, response);
+    });
+  }
+  static addAccessTokenRefreshListener(handler) {
+    window.addEventListener("message", (event) => {
+      const msg = event.data;
+      if (msg.type === "auth_token") {
+        handler(msg.token);
       }
     });
   }
-  async request(data) {
-    if (!this.channel) {
-      await this.initialize();
-    }
-    if (!this.channel) {
-      throw new Error("Failed to create channel");
+  static addModuleDataListener(handler) {
+    const moduleName2 = this.getCurrentModuleContext();
+    if (moduleName2) {
+      this.sendAppMessage({ type: "request_module_data", module: moduleName2 });
     }
-    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");
-          }
-        }
+    window.addEventListener("message", (event) => {
+      const msg = event.data;
+      if (msg.type === "module_data") {
+        handler({
+          streams: msg.streams,
+          time: msg.time,
+          queryRange: msg.queryRange
+        });
       }
-    }
-    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");
+  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
+          )
+        );
       }
-      if (this.requestIdToResponseMap.has(id)) {
-        this.requestIdToResponseMap.set(id, response);
+    };
+    window.addEventListener("message", listener);
+    return () => window.removeEventListener("message", listener);
+  }
+  static addModuleConfigurationListener(handler) {
+    window.addEventListener("message", (event) => {
+      const msg = event.data;
+      if (msg.type === "module_configuration") {
+        handler(msg);
       }
     });
   }
-  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 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");
-          }
-        }
+  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
+        });
       }
-    }
-    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 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));
+  static requestOverviewDevices(handler) {
+    this.sendAppMessage({ type: "request_devices" });
+    window.addEventListener("message", (event) => {
+      const msg = event.data;
+      handler(msg);
     });
-    this.id = id;
-    this.name = name;
-    this.organizationId = organizationId;
   }
-  async getLatestTelemetry() {
-    const data = await fetch(
-      `${FORMANT_API_URL}/v1/queries/stream-current-value`,
-      {
+  static async prompt(schema, options) {
+    return new Promise((resolve) => {
+      const promptId = Math.random().toString();
+      this.sendAppMessage({
+        type: "prompt",
+        promptId,
+        schema,
+        okText: options == null ? void 0 : options.okText,
+        cancelText: options == null ? void 0 : options.cancelText
+      });
+      const handler = (event) => {
+        const msg = event.data;
+        if (msg.type === "prompt_response" && msg.promptId === promptId) {
+          resolve(msg.data);
+        }
+        window.removeEventListener("message", handler);
+      };
+      window.addEventListener("message", handler);
+    });
+  }
+}
+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({
-          deviceIds: [this.id]
-        }),
+        body: JSON.stringify({ email, password }),
         headers: {
-          "Content-Type": "application/json",
-          Authorization: "Bearer " + Authentication.token
+          "Content-Type": "application/json"
         }
+      });
+      const auth = await result.json();
+      if (result.status !== 200) {
+        throw new Error(auth.message);
       }
-    );
-    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 device = await result.json();
-    if (!device.state.reportedConfiguration) {
-      throw new Error(
-        "Device has no configuration, has it ever been turned on?"
+      await _Authentication.loginWithToken(
+        auth.authentication.accessToken,
+        auth.authentication.refreshToken
       );
+      return auth.authentication;
+    } catch (e) {
+      _Authentication.waitingForAuth.forEach((_) => _(false));
+      _Authentication.waitingForAuth = [];
+      return Promise.reject(e);
     }
-    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;
   }
-  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
+  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;
       }
-    });
-    const files = await result.json();
-    return files.fileUrls;
-  }
-  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}`);
-    }
-  }
-  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}`);
-    }
-  }
-  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 (tokenData["custom:organization_id"]) {
+        _Authentication.currentOrganization = tokenData["custom:organization_id"];
       }
-      if (rtcClient.isReady) {
-        while (!rtcClient.isReady()) {
-          await delay(100);
-        }
+      if (!_Authentication.isShareToken) {
+        userId = tokenData.sub;
       }
-      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}`
-      );
-    }
-  }
-  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);
-  }
-  removeRealtimeListener(listener) {
-    const i = this.realtimeListeners.indexOf(listener);
-    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;
-  }
-  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
-        });
-      }
-    }
-    for (const _ of (_d = (_c = document2.teleop) == null ? void 0 : _c.rosStreams) != null ? _d : []) {
-      if (_.topicType == "formant/H264VideoFrame") {
-        streams.push({
-          name: _.topicName
-        });
-      }
-    }
-    for (const _ of (_f = (_e = document2.teleop) == null ? void 0 : _e.customStreams) != null ? _f : []) {
-      if (_.rtcStreamType === "h264-video-frame") {
-        streams.push({
-          name: _.name
-        });
+      if (tokenData["formant:claims"] && tokenData["formant:claims"].userId) {
+        userId = tokenData["formant:claims"].userId;
       }
-    }
-    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
-          })
+      if (userId) {
+        const result = await fetch(
+          `${FORMANT_API_URL}/v1/admin/users/${userId}`,
+          {
+            method: "GET",
+            headers: {
+              "Content-Type": "application/json",
+              Authorization: "Bearer " + token
+            }
+          }
         );
-      }
-    }
-    return manipulators;
-  }
-  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 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"
-    });
-  }
-  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"
-    });
-  }
-  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"
-    });
-  }
-  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"
-    });
-  }
-  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,
-      "Realtime connection has not been started"
-    );
-    const devicePeer = await this.getRemotePeer();
-    client.controlRemoteStream(defined(devicePeer).id, {
-      streamName,
-      enablePriorityUpload: false,
-      pipeline: "telemetry"
-    });
-  }
-  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
-    );
-  }
-  async stopRealtimeConnection() {
-    if (this.rtcClient) {
-      await this.rtcClient.disconnect(this.id);
-    } else {
-      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;
-    }
-    return false;
-  }
-  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 data = await result.json();
+        if (result.status !== 200) {
+          throw new Error(data.message);
         }
+        _Authentication.currentUser = data;
       }
-    );
-    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 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}"`);
-    }
-    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;
-    }
-    let parameter = {
-      value: d,
-      scrubberTime: (time || new Date()).toISOString(),
-      meta: {
-        ...command.parameterMeta,
-        ...metadata
-      }
-    };
-    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 createCustomDataChannel(channelName, rtcConfig) {
-    if (rtcClientVersion === "1") {
-      throw new Error(
-        "createCustomDataChannel is not supported in rtcClientVersion 1"
-      );
+      _Authentication.token = token;
+      _Authentication.waitingForAuth.forEach((_) => _(true));
+    } catch (e) {
+      console.error(e);
+      _Authentication.waitingForAuth.forEach((_) => _(false));
     }
-    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);
+    _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;
         }
-      );
-    });
-    await p.waitTilReady();
-    return p;
-  }
-  createCustomRequestDataChannel(channelName, timeout = 3e3) {
-    return new TextRequestDataChannel(this, channelName, timeout);
+      }, 1e3 * 60 * 60);
+    }
   }
-  createCustomBinaryRequestDataChannel(channelName, timeout = 3e3) {
-    return new BinaryRequestDataChannel(this, channelName, timeout);
+  static isAuthenticated() {
+    return _Authentication.token !== void 0;
   }
-  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
-      }
-    });
-    const captureSession = await result.json();
-    return new CaptureStream(captureSession);
+  static getCurrentUser() {
+    return _Authentication.currentUser;
   }
-  async getTelemetry(streamNameOrStreamNames, start, end, tags) {
-    return await Fleet.getTelemetry(
-      this.id,
-      streamNameOrStreamNames,
-      start,
-      end,
-      tags
-    );
+  static async waitTilAuthenticated() {
+    if (_Authentication.token !== void 0) {
+      return true;
+    } else {
+      return new Promise((resolve) => {
+        _Authentication.waitingForAuth.push(function(result) {
+          resolve(result);
+        });
+      });
+    }
   }
-  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({
-          deviceIds: [this.id]
-        }),
-        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);
-      }
+  static async listenForRefresh() {
+    App.addAccessTokenRefreshListener((token) => {
+      this.loginWithToken(token);
     });
-    console.log(onDemandList);
-    const data = await result.json();
-    let streamNames = data.items.filter((_) => !disabledList.includes(_)).map((_) => ({ name: _, onDemand: onDemandList.includes(_) }));
-    return streamNames;
+    setInterval(async () => {
+      App.refreshAuthToken();
+    }, 1e3 * 60 * 60);
   }
-  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
-        }
-      }
-    );
-    const interventionJson = await intervention.json();
-    return interventionJson;
+};
+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));
+      });
+    };
   }
-  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;
+  addOpenListener(listener) {
+    this.openListeners.push(listener);
   }
-}
-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;
+  removeOpenListener(listener) {
+    this.openListeners = this.openListeners.filter((_) => _ !== listener);
   }
-  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;
-    });
+  addCloseListener(listener) {
+    this.closeListeners.push(listener);
   }
-  async getDeviceId() {
-    let result = await fetch(`${this.peerUrl}/configuration`);
-    const cfg = await result.json();
-    return cfg.agent_config.id;
+  removeCloseListener(listener) {
+    this.closeListeners = this.closeListeners.filter((l) => l !== listener);
   }
-  async getConfiguration() {
-    let result = await fetch(`${this.peerUrl}/configuration`);
-    const cfg = await result.json();
-    return cfg.agent_config.document;
+  addErrorListener(listener) {
+    this.errorListeners.push(listener);
   }
-  getRealtimeStatus() {
-    if (this.rtcClient && this.remoteDevicePeerId) {
-      return this.rtcClient.getConnectionStatus(this.remoteDevicePeerId);
-    } else {
-      throw new Error(`Realtime connection hasn't been started`);
-    }
+  removeErrorListener(listener) {
+    this.errorListeners = this.errorListeners.filter((l) => l !== listener);
   }
-  getRealtimePing() {
-    if (this.rtcClient && this.remoteDevicePeerId) {
-      return this.rtcClient.getPing(this.remoteDevicePeerId);
-    } else {
-      throw new Error(`Realtime connection hasn't been started`);
+  async waitTilReady() {
+    if (this.ready) {
+      return true;
+    }
+    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;
+  }
+  send(data) {
+    if (!this.ready) {
+      throw new Error("Connection has been closed");
     }
+    this.dataChannel.send(data);
   }
-  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}`
-      );
+  sendBinary(data) {
+    if (!this.ready) {
+      throw new Error("Connection has been closed");
     }
+    this.dataChannel.send(data);
   }
-  addRealtimeListener(listener) {
-    this.realtimeListeners.push(listener);
+  addListener(listener) {
+    this.listeners.push(listener);
   }
-  removeRealtimeListener(listener) {
-    const i = this.realtimeListeners.indexOf(listener);
+  removeListener(listener) {
+    const i = this.listeners.indexOf(listener);
     if (i === -1) {
-      throw new Error("Could not find realtime listener to remove");
-    }
-    this.realtimeListeners.splice(i, 1);
-  }
-  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
-        });
-      }
-    }
-    for (const _ of (_b = document2.teleop.rosStreams) != null ? _b : []) {
-      if (_.topicType == "formant/H264VideoFrame") {
-        streams.push({
-          name: _.topicName
-        });
-      }
+      throw new Error("Could not find data channel listener to remove");
     }
-    for (const _ of (_c = document2.teleop.customStreams) != null ? _c : []) {
-      if (_.rtcStreamType === "h264-video-frame") {
-        streams.push({
-          name: _.name
-        });
-      }
+    if (this.error) {
+      throw new Error(this.error);
     }
-    return streams;
+    this.listeners.splice(i, 1);
   }
-  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;
+  addBinaryListener(listener) {
+    this.binaryListeners.push(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"
-    });
+  removeBinaryListener(listener) {
+    const i = this.binaryListeners.indexOf(listener);
+    if (i === -1) {
+      throw new Error("Could not find data channel listener to remove");
+    }
+    if (this.error) {
+      throw new Error(this.error);
+    }
+    this.binaryListeners.splice(i, 1);
   }
-  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"
-    });
+}
+class CaptureStream {
+  constructor(captureSession) {
+    __publicField(this, "token");
+    this.captureSession = captureSession;
   }
-  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"
+  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
+      }
     });
   }
-  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"
+}
+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;
   }
-  async enableRealtimeTelemetryPriorityIngestion(streamName) {
-    const client = defined(
-      this.rtcClient,
-      "Realtime connection has not been started"
+  async synchronize() {
+    this.device.addRealtimeListener(this.onRealtimeMessage);
+    this.device.startListeningToRealtimeDataStream(
+      this.config.currentJointStateStream
     );
-    const devicePeer = await this.getRemotePeer();
-    client.controlRemoteStream(defined(devicePeer).id, {
-      streamName,
-      enablePriorityUpload: true,
-      pipeline: "telemetry"
-    });
   }
-  async disableRealtimeTelemetryPriorityIngestion(streamName) {
-    const client = defined(
-      this.rtcClient,
-      "Realtime connection has not been started"
+  async desynchronize() {
+    this.device.removeRealtimeListener(this.onRealtimeMessage);
+    this.device.stopListeningToRealtimeDataStream(
+      this.config.currentJointStateStream
     );
-    const devicePeer = await this.getRemotePeer();
-    client.controlRemoteStream(defined(devicePeer).id, {
-      streamName,
-      enablePriorityUpload: false,
-      pipeline: "telemetry"
-    });
-  }
-  async getRemotePeer() {
-    return {
-      id: this.peerUrl,
-      organizationId: "",
-      deviceId: this.id,
-      capabilities: [],
-      capabilitySet: {}
-    };
   }
-  async stopRealtimeConnection() {
-    if (this.rtcClient) {
-      await this.rtcClient.disconnect(this.id);
-    } else {
-      throw new Error(`Realtime connection hasn't been started for ${this.id}`);
-    }
+  async addCurrentJointStateListener(listener) {
+    this.currentListeners.push(listener);
   }
-  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;
+}
+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;
   }
-  createCustomRequestDataChannel(channelName, timeout = 3e3) {
-    return new TextRequestDataChannel(this, channelName, timeout);
+  addOpenListener(listener) {
+    defined(this.channel, "channel not initalized").addOpenListener(listener);
   }
-  createCustomBinaryRequestDataChannel(channelName, timeout = 3e3) {
-    return new BinaryRequestDataChannel(this, channelName, timeout);
+  removeOpenListener(listener) {
+    defined(this.channel, "channel not initalized").removeOpenListener(
+      listener
+    );
   }
-}
-const _Fleet$1 = class {
-  static async setDefaultDevice(deviceId) {
-    _Fleet$1.defaultDeviceId = deviceId;
+  addCloseListener(listener) {
+    defined(this.channel, "channel not initalized").addCloseListener(listener);
   }
-  static async getCurrentDevice() {
-    if (!Authentication.token) {
-      throw new Error("Not authenticated");
-    }
-    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)
+  removeCloseListener(listener) {
+    defined(this.channel, "channel not initalized").removeCloseListener(
+      listener
     );
-    _Fleet$1.knownContext.push(new WeakRef(context));
-    return context;
   }
-  static async getPeerDevice(url) {
-    const peer = new PeerDevice(url);
-    peer.id = await peer.getDeviceId();
-    return peer;
+  addErrorListener(listener) {
+    defined(this.channel, "channel not initalized").addErrorListener(listener);
   }
-  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: {
-          "Content-Type": "application/json",
-          Authorization: "Bearer " + Authentication.token
-        }
-      }
+  removeErrorListener(listener) {
+    defined(this.channel, "channel not initalized").removeErrorListener(
+      listener
     );
-    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;
   }
-  static async getDevices() {
-    if (!Authentication.token) {
-      throw new Error("Not authenticated");
-    }
-    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)
-    );
+}
+class BinaryRequestDataChannel extends RequestDataChannel {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "RESPONSE_SUCCESS_BYTE", 0);
+    __publicField(this, "decoder", new TextDecoder());
   }
-  static async queryDevices(query) {
-    if (!Authentication.token) {
-      throw new Error("Not authenticated");
+  generateBinaryId() {
+    const id = new Uint8Array(16);
+    for (let i = 0; i < id.length; i++) {
+      id[i] = Math.floor(Math.random() * 256);
     }
-    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
+    return 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");
+      }
+      const response = message.slice(16);
+      if (response.length === 0) {
+        throw new Error("Invalid response");
+      }
+      if (this.requestIdToResponseMap.has(id)) {
+        this.requestIdToResponseMap.set(id, response);
       }
     });
-    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");
+  async request(data) {
+    if (!this.channel) {
+      await this.initialize();
     }
-    const data = await fetch(`${FORMANT_API_URL}/v1/queries/online-devices`, {
-      method: "GET",
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: "Bearer " + Authentication.token
+    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");
+          }
+        }
       }
+    }
+    requestIdToResponseMap.delete(id);
+    console.error({
+      name: "TimeoutError",
+      message: `Request timed out after ${timeout / 1e3} seconds`
     });
-    const devices = await data.json();
-    const onlineIds = devices.items;
-    const allDevices = await _Fleet$1.getDevices();
-    return allDevices.filter((_) => onlineIds.includes(_.id));
+    throw new Error("Binary request data channel request timed out");
   }
-  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: () => {
+}
+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");
+      }
+      if (this.requestIdToResponseMap.has(id)) {
+        this.requestIdToResponseMap.set(id, response);
       }
     });
-    return await rtcClient.getPeers();
   }
-  static async getRealtimeSessions() {
-    if (!Authentication.token) {
-      throw new Error("Not authenticated");
+  async request(data) {
+    if (!this.channel) {
+      await this.initialize();
     }
-    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: () => {
+    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`
     });
-    return await rtcClient.getSessions();
+    throw new Error("Text request datachannel request timed out");
   }
-  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 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));
     });
-    const devices = await data.json();
-    const onlineIds = devices.items.map(
-      (_) => _.deviceId
-    );
-    const allDevices = await _Fleet$1.getDevices();
-    return allDevices.filter((_) => onlineIds.includes(_.id));
+    this.id = id;
+    this.name = name;
+    this.organizationId = organizationId;
   }
-  static async getLatestTelemetry(deviceIdOrDeviceIds) {
-    let deviceIds = deviceIdOrDeviceIds;
-    if (deviceIdOrDeviceIds && !Array.isArray(deviceIdOrDeviceIds)) {
-      deviceIdOrDeviceIds = [deviceIdOrDeviceIds];
-    }
+  async getLatestTelemetry() {
     const data = await fetch(
       `${FORMANT_API_URL}/v1/queries/stream-current-value`,
       {
         method: "POST",
         body: JSON.stringify({
-          deviceIds
+          deviceIds: [this.id]
         }),
         headers: {
           "Content-Type": "application/json",
@@ -20556,680 +20114,765 @@ const _Fleet$1 = class {
     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 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
-      }),
+  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 telemetry = await data.json();
-    return telemetry.items;
+    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;
   }
-  static async getFileUrl(uuid) {
-    const data = await fetch(`${FORMANT_API_URL}/v1/admin/files/query`, {
+  async getFileUrl(fileId) {
+    const result = await fetch(`${FORMANT_API_URL}/v1/admin/files/query`, {
       method: "POST",
       body: JSON.stringify({
-        fileIds: [uuid]
+        fileIds: [fileId]
       }),
       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];
+    const files = await result.json();
+    return files.fileUrls;
   }
-  static async queryTelemetry(query) {
-    if (!Authentication.token) {
-      throw new Error("Not authenticated");
+  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}`);
     }
-    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()).items;
   }
-  static async aggregateTelemetry(query) {
-    if (!Authentication.token) {
-      throw new Error("Not authenticated");
+  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 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;
   }
-  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(query),
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: "Bearer " + Authentication.token
+  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
+        });
       }
-    });
-    return (await data.json()).items;
-  }
-  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
+      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") {
+        await delay(100);
+      }
+      this.rtcClient = rtcClient;
+    } else {
+      throw new Error(
+        `Already created realtime connection to device ${this.id}`
+      );
+    }
+  }
+  async sendRealtimeMessage(message, config = {
+    channelLabel: "stream.reliable"
+  }) {
+    const client = defined(
+      this.rtcClient,
+      "Realtime connection has not been started"
     );
-    return (await data.json()).items;
+    const devicePeer = await this.getRemotePeer();
+    client.send(defined(devicePeer).id, message, config);
   }
-  static async getInterventions() {
-    if (!Authentication.token) {
-      throw new Error("Not authenticated");
+  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");
     }
-    const interventions = await fetch(
-      `${FORMANT_API_URL}/v1/admin/intervention-requests`,
-      {
-        method: "GET",
-        headers: {
-          "Content-Type": "application/json",
-          Authorization: "Bearer " + Authentication.token
-        }
+    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 (await interventions.json()).items;
+    }
+    return streams;
   }
-  static async getCurrentGroup() {
-    if (!Authentication.token) {
-      throw new Error("Not authenticated");
+  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
+        });
+      }
     }
-    let urlParams2 = new URLSearchParams("");
-    if (typeof window !== "undefined") {
-      urlParams2 = new URLSearchParams(window.location.search);
+    for (const _ of (_d = (_c = document2.teleop) == null ? void 0 : _c.rosStreams) != null ? _d : []) {
+      if (_.topicType == "formant/H264VideoFrame") {
+        streams.push({
+          name: _.topicName
+        });
+      }
     }
-    const groupId = urlParams2.get("group");
-    if (groupId === null || groupId.trim() === "") {
-      return void 0;
+    for (const _ of (_f = (_e = document2.teleop) == null ? void 0 : _e.customStreams) != null ? _f : []) {
+      if (_.rtcStreamType === "h264-video-frame") {
+        streams.push({
+          name: _.name
+        });
+      }
     }
-    const response = await fetch(
-      `${FORMANT_API_URL}/v1/admin/groups/` + groupId,
-      {
-        headers: {
-          "Content-Type": "application/json",
-          Authorization: "Bearer " + Authentication.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
+          })
+        );
       }
+    }
+    return manipulators;
+  }
+  async startListeningToRealtimeVideo(stream) {
+    const client = defined(
+      this.rtcClient,
+      "Realtime connection has not been started"
     );
-    const { tagKey, tagValue } = await response.json();
-    const devices = await this.queryDevices({
-      tags: { [tagKey]: [tagValue] },
-      enabled: true,
-      type: "default"
+    const devicePeer = await this.getRemotePeer();
+    client.controlRemoteStream(defined(devicePeer).id, {
+      streamName: stream.name,
+      enable: true,
+      pipeline: "rtc"
     });
-    return devices;
   }
-  static async getAnnotationCount(query) {
-    const tagKey = query.tagKey;
-    delete query.tagKey, delete query.aggregate;
-    const annotations = await this.queryEvents({
-      ...query,
-      eventTypes: ["annotation"]
-    });
-    const validAnnotations = annotations.filter(
-      (_) => !!_.tags && Object.keys(_.tags).includes(tagKey)
+  async stopListeningToRealtimeVideo(stream) {
+    const client = defined(
+      this.rtcClient,
+      "Realtime connection has not been started"
     );
-    const annotationCounter = validAnnotations.reduce((prev, current) => {
-      const value = current.tags[tagKey];
-      if (value in prev) {
-        prev[value] += 1;
-        return prev;
-      }
-      prev[value] = 1;
-      return prev;
-    }, {});
-    return annotationCounter;
+    const devicePeer = await this.getRemotePeer();
+    client.controlRemoteStream(defined(devicePeer).id, {
+      streamName: stream.name,
+      enable: false,
+      pipeline: "rtc"
+    });
   }
-};
-let Fleet$1 = _Fleet$1;
-__publicField(Fleet$1, "defaultDeviceId");
-__publicField(Fleet$1, "knownContext", []);
-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;
+  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"
+    });
   }
-  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;
+  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"
+    });
   }
-  set(key, value) {
-    const cacheKey = this.keyToCacheKey(key);
-    this.metadata.set(cacheKey, {
-      generating: false,
-      expiration: new Date(Date.now() + this.timeout),
-      lastValue: value
+  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"
     });
-    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);
+  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
+    });
   }
-  clearKey(key) {
-    this.metadata.delete(key);
-    this.entries.delete(key);
+  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"
+    });
   }
-  keyToCacheKey(key) {
-    return JSON.stringify(key);
+  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
+    );
   }
-  deleteOldestEntry() {
-    if (this.metadata.size < 1) {
-      return;
+  async stopRealtimeConnection() {
+    if (this.rtcClient) {
+      await this.rtcClient.disconnect(this.id);
+    } else {
+      throw new Error(`Realtime connection hasn't been started for ${this.id}`);
     }
-    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);
+  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 false;
   }
-}
-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
+  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
     }));
   }
-  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;
+  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}"`);
     }
-    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);
+    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 {
-      data = this.queryCache(q);
-    }
-    if (!data || data === "too much data") {
-      return data;
+      d = data;
     }
-    if (latestOnly) {
-      return data;
+    let parameter = {
+      value: d,
+      scrubberTime: (time || new Date()).toISOString(),
+      meta: {
+        ...command.parameterMeta,
+        ...metadata
+      }
+    };
+    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 createCustomDataChannel(channelName, rtcConfig) {
+    if (rtcClientVersion === "1") {
+      throw new Error(
+        "createCustomDataChannel is not supported in rtcClientVersion 1"
+      );
     }
-    return filterDataByTime(data, start, end);
+    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;
   }
-  queryCache(query) {
-    return this.queryStoreCache.get(query, async () => {
-      try {
-        return await Fleet$1.queryTelemetry(query);
-      } catch (error) {
-        throw error;
+  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
       }
     });
+    const captureSession = await result.json();
+    return new CaptureStream(captureSession);
   }
-  liveQueryCache(query) {
-    return this.liveQueryStoreCache.get(query, async () => {
-      try {
-        return await Fleet$1.queryTelemetry(query);
-      } catch (error) {
-        throw error;
+  async getTelemetry(streamNameOrStreamNames, start, end, tags) {
+    return await Fleet.getTelemetry(
+      this.id,
+      streamNameOrStreamNames,
+      start,
+      end,
+      tags
+    );
+  }
+  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({
+          deviceIds: [this.id]
+        }),
+        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);
       }
     });
+    console.log(onDemandList);
+    const data = await result.json();
+    let streamNames = data.items.filter((_) => !disabledList.includes(_)).map((_) => ({ name: _, onDemand: onDemandList.includes(_) }));
+    return streamNames;
   }
-}
-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;
+  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
+        }
+      }
+    );
+    const interventionJson = await intervention.json();
+    return interventionJson;
   }
-  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;
-    }
+  async addInterventionResponse(interventionId, interventionType, data) {
     const response = await fetch(
-      `${FORMANT_API_URL}/v1/admin/module-configurations/` + configurationId,
+      `${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 moduleConfiguration = await response.json();
-    return moduleConfiguration.configuration;
-  }
-  static isModule() {
-    return this.getCurrentModuleContext() !== null;
-  }
-  static goToTime(date) {
-    this.sendAppMessage({
-      type: "go_to_time",
-      time: date.getTime()
-    });
-  }
-  static goToDevice(deviceId) {
-    this.sendAppMessage({
-      type: "go_to_device",
-      deviceId
-    });
-  }
-  static showMessage(message) {
-    this.sendAppMessage({ type: "show_message", message });
+    const interventionResponse = await response.json();
+    return interventionResponse;
   }
-  static requestModuleData() {
-    const moduleName2 = this.getCurrentModuleContext();
-    if (!moduleName2) {
-      throw new Error("No module context");
-    }
-    this.sendAppMessage({
-      type: "request_module_data",
-      module: moduleName2
+}
+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 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 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 refreshAuthToken() {
-    const moduleName2 = this.getCurrentModuleContext();
-    if (!moduleName2) {
-      throw new Error("No module context");
-    }
-    this.sendAppMessage({
-      type: "refresh_auth_token",
-      module: moduleName2
-    });
+  async getDeviceId() {
+    let result = await fetch(`${this.peerUrl}/configuration`);
+    const cfg = await result.json();
+    return cfg.agent_config.id;
   }
-  static sendChannelData(channel, data) {
-    const moduleName2 = this.getCurrentModuleContext();
-    if (!moduleName2) {
-      throw new Error("No module context");
-    }
-    this.sendAppMessage({
-      type: "send_channel_data",
-      source: moduleName2,
-      channel,
-      data
-    });
+  async getConfiguration() {
+    let result = await fetch(`${this.peerUrl}/configuration`);
+    const cfg = await result.json();
+    return cfg.agent_config.document;
   }
-  static setupModuleMenus(menus) {
-    const moduleName2 = this.getCurrentModuleContext();
-    if (!moduleName2) {
-      throw new Error("No module context");
+  getRealtimeStatus() {
+    if (this.rtcClient && this.remoteDevicePeerId) {
+      return this.rtcClient.getConnectionStatus(this.remoteDevicePeerId);
+    } else {
+      throw new Error(`Realtime connection hasn't been started`);
     }
-    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);
-      }
-    });
-  }
-  static addAccessTokenRefreshListener(handler) {
-    window.addEventListener("message", (event) => {
-      const msg = event.data;
-      if (msg.type === "auth_token") {
-        handler(msg.token);
-      }
-    });
   }
-  static addModuleDataListener(handler) {
-    const moduleName2 = this.getCurrentModuleContext();
-    if (moduleName2) {
-      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`);
     }
-    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
-          )
-        );
-      }
-    };
-    window.addEventListener("message", listener);
-    return () => window.removeEventListener("message", listener);
-  }
-  static addModuleConfigurationListener(handler) {
-    window.addEventListener("message", (event) => {
-      const msg = event.data;
-      if (msg.type === "module_configuration") {
-        handler(msg);
-      }
-    });
   }
-  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
-        });
-      }
-    });
-  }
-  static requestOverviewDevices(handler) {
-    this.sendAppMessage({ type: "request_devices" });
-    window.addEventListener("message", (event) => {
-      const msg = event.data;
-      handler(msg);
-    });
-  }
-  static async prompt(schema, options) {
-    return new Promise((resolve) => {
-      const promptId = Math.random().toString();
-      this.sendAppMessage({
-        type: "prompt",
-        promptId,
-        schema,
-        okText: options == null ? void 0 : options.okText,
-        cancelText: options == null ? void 0 : options.cancelText
-      });
-      const handler = (event) => {
-        const msg = event.data;
-        if (msg.type === "prompt_response" && msg.promptId === promptId) {
-          resolve(msg.data);
-        }
-        window.removeEventListener("message", handler);
-      };
-      window.addEventListener("message", handler);
-    });
-  }
-}
-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"
-        }
+  async startRealtimeConnection(sessionType) {
+    if (!this.rtcClient) {
+      const rtcClient = new dist.exports.RtcClient({
+        lanOnlyMode: true,
+        receive: this.handleMessage,
+        sessionType
       });
-      const auth = await result.json();
-      if (result.status !== 200) {
-        throw new Error(auth.message);
-      }
-      await _Authentication.loginWithToken(
-        auth.authentication.accessToken,
-        auth.authentication.refreshToken
+      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}`
       );
-      return auth.authentication;
-    } catch (e) {
-      _Authentication.waitingForAuth.forEach((_) => _(false));
-      _Authentication.waitingForAuth = [];
-      return Promise.reject(e);
     }
   }
-  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"];
+  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");
+    }
+    this.realtimeListeners.splice(i, 1);
+  }
+  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
+        });
       }
-      if (!_Authentication.isShareToken) {
-        userId = tokenData.sub;
+    }
+    for (const _ of (_b = document2.teleop.rosStreams) != null ? _b : []) {
+      if (_.topicType == "formant/H264VideoFrame") {
+        streams.push({
+          name: _.topicName
+        });
       }
-      if (tokenData["formant:claims"] && tokenData["formant:claims"].userId) {
-        userId = tokenData["formant:claims"].userId;
+    }
+    for (const _ of (_c = document2.teleop.customStreams) != null ? _c : []) {
+      if (_.rtcStreamType === "h264-video-frame") {
+        streams.push({
+          name: _.name
+        });
       }
-      if (userId) {
-        const result = await fetch(
-          `${FORMANT_API_URL}/v1/admin/users/${userId}`,
-          {
-            method: "GET",
-            headers: {
-              "Content-Type": "application/json",
-              Authorization: "Bearer " + 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
+          })
         );
-        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);
     }
+    return manipulators;
   }
-  static isAuthenticated() {
-    return _Authentication.token !== void 0;
+  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 getCurrentUser() {
-    return _Authentication.currentUser;
+  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 async waitTilAuthenticated() {
-    if (_Authentication.token !== void 0) {
-      return true;
+  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"
+    });
+  }
+  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"
+    });
+  }
+  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"
+    });
+  }
+  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"
+    });
+  }
+  async getRemotePeer() {
+    return {
+      id: this.peerUrl,
+      organizationId: "",
+      deviceId: this.id,
+      capabilities: [],
+      capabilitySet: {}
+    };
+  }
+  async stopRealtimeConnection() {
+    if (this.rtcClient) {
+      await this.rtcClient.disconnect(this.id);
     } else {
-      return new Promise((resolve) => {
-        _Authentication.waitingForAuth.push(function(result) {
-          resolve(result);
-        });
-      });
+      throw new Error(`Realtime connection hasn't been started for ${this.id}`);
     }
   }
-  static async listenForRefresh() {
-    App.addAccessTokenRefreshListener((token) => {
-      this.loginWithToken(token);
+  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);
+        }
+      );
     });
-    setInterval(async () => {
-      App.refreshAuthToken();
-    }, 1e3 * 60 * 60);
+    await p.waitTilReady();
+    return p;
   }
-};
-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", []);
+  createCustomRequestDataChannel(channelName, timeout = 3e3) {
+    return new TextRequestDataChannel(this, channelName, timeout);
+  }
+  createCustomBinaryRequestDataChannel(channelName, timeout = 3e3) {
+    return new BinaryRequestDataChannel(this, channelName, timeout);
+  }
+}
 const _Fleet = class {
   static async setDefaultDevice(deviceId) {
     _Fleet.defaultDeviceId = deviceId;