@eyepop.ai/eyepop 3.18.0 → 3.19.1

package/dist/eyepop.index.js

@@ -8671,11 +8671,13 @@ __export(index_exports, {
   DEFAULT_PREDICTION_VERSION: () => DEFAULT_PREDICTION_VERSION,
   DataApiType: () => DataApiType,
   DataEndpoint: () => DataEndpoint,
+  DepthMap: () => DepthMap,
   Endpoint: () => Endpoint,
   EndpointState: () => EndpointState,
   EvaluationStatus: () => EvaluationStatus,
   ExportedBy: () => ExportedBy,
   EyePop: () => EyePop,
+  EyePopDataWebSocketError: () => EyePopDataWebSocketError,
   EyepopLineDecoder: () => EyepopLineDecoder,
   ForwardOperatorType: () => ForwardOperatorType,
   InferenceType: () => InferenceType,
@@ -8711,6 +8713,7 @@ __export(index_exports, {
   WorkflowPhase: () => WorkflowPhase,
   accessTokenCredential: () => accessTokenCredential,
   apiKeyCredential: () => apiKeyCredential,
+  decodeDepthMap: () => decodeDepthMap,
   default: () => index_default,
   encodeMultipartFormData: () => encodeMultipartFormData,
   getBaseUrl: () => getBaseUrl,
@@ -11520,57 +11523,8 @@ if ("document" in globalThis && "implementation" in globalThis.document) {
   };
 }
 
-// ../../node_modules/url-join/lib/url-join.js
-function normalize(strArray) {
-  var resultArray = [];
-  if (strArray.length === 0) {
-    return "";
-  }
-  if (typeof strArray[0] !== "string") {
-    throw new TypeError("Url must be a string. Received " + strArray[0]);
-  }
-  if (strArray[0].match(/^[^/:]+:\/*$/) && strArray.length > 1) {
-    var first = strArray.shift();
-    strArray[0] = first + strArray[0];
-  }
-  if (strArray[0].match(/^file:\/\/\//)) {
-    strArray[0] = strArray[0].replace(/^([^/:]+):\/*/, "$1:///");
-  } else {
-    strArray[0] = strArray[0].replace(/^([^/:]+):\/*/, "$1://");
-  }
-  for (var i = 0; i < strArray.length; i++) {
-    var component = strArray[i];
-    if (typeof component !== "string") {
-      throw new TypeError("Url must be a string. Received " + component);
-    }
-    if (component === "") {
-      continue;
-    }
-    if (i > 0) {
-      component = component.replace(/^[\/]+/, "");
-    }
-    if (i < strArray.length - 1) {
-      component = component.replace(/[\/]+$/, "");
-    } else {
-      component = component.replace(/[\/]+$/, "/");
-    }
-    resultArray.push(component);
-  }
-  var str = resultArray.join("/");
-  str = str.replace(/\/(\?|&|#[^!])/g, "$1");
-  var parts = str.split("?");
-  str = parts.shift() + (parts.length > 0 ? "?" : "") + parts.join("&");
-  return str;
-}
-function urlJoin() {
-  var input;
-  if (typeof arguments[0] === "object") {
-    input = arguments[0];
-  } else {
-    input = [].slice.call(arguments);
-  }
-  return normalize(input);
-}
+// data/data_endpoint.ts
+var import_url_join = __toESM(require("url-join"));
 
 // data/data_types.ts
 var DataApiType = /* @__PURE__ */ ((DataApiType2) => {
@@ -11923,6 +11877,33 @@ var EvaluateDatasetJob = class {
 // data/data_endpoint.ts
 var WS_INITIAL_RECONNECT_DELAY = 1e3;
 var WS_MAX_RECONNECT_DELAY = 6e4;
+function ws_origin(url) {
+  try {
+    return new URL(url).origin;
+  } catch {
+    return url;
+  }
+}
+function ws_failure_reason(event, sourceError) {
+  if (sourceError instanceof Error) {
+    return sourceError.message;
+  }
+  if (typeof sourceError === "string") {
+    return sourceError;
+  }
+  return event?.message ?? "";
+}
+var EyePopDataWebSocketError = class extends Error {
+  constructor(url, event) {
+    const sourceError = event?.error ?? event;
+    const reason = ws_failure_reason(event, sourceError);
+    super(reason ? `EyePop Dataset event WebSocket connection failed: ${reason}` : "EyePop Dataset event WebSocket connection failed");
+    this.code = "DATA_WEBSOCKET_CONNECTION_FAILED";
+    this.name = "EyePopDataWebSocketError";
+    this.endpoint = ws_origin(url);
+    this.sourceError = sourceError;
+  }
+};
 function omit_nulls(_, value) {
   if (value === null) {
     return void 0;
@@ -11936,6 +11917,9 @@ var DataEndpoint = class extends Endpoint {
     this.vlmApiUrl = null;
     this._ws = null;
     this._ws_current_reconnect_delay = null;
+    this._ws_reconnect_timeout = null;
+    this._ws_reconnect_enabled = false;
+    this._ws_connecting = null;
     this._accountId = options.accountId || null;
     this._account_event_handlers = [];
     this._dataset_uuid_to_event_handlers = /* @__PURE__ */ new Map();
@@ -11959,14 +11943,15 @@ var DataEndpoint = class extends Endpoint {
     };
   }
   async disconnect(wait = true) {
+    this._ws_reconnect_enabled = false;
+    if (this._ws_reconnect_timeout) {
+      clearTimeout(this._ws_reconnect_timeout);
+      this._ws_reconnect_timeout = null;
+    }
     this.datasetApiUrl = null;
     this.vlmApiUrl = null;
     if (this._ws) {
-      try {
-        this._ws.close();
-      } catch (e) {
-        this._logger.warn("ignored exception", e);
-      }
+      this.close_ws(this._ws, "unsubscribe");
       this._ws = null;
     }
     await super.disconnect(wait);
@@ -12004,13 +11989,14 @@ var DataEndpoint = class extends Endpoint {
     const vlmApiUrl = new URL(config.vlm_api_url, this.eyepopUrl());
     this.vlmApiUrl = vlmApiUrl.toString();
     if (this.options().disableWs) {
+      this._ws_reconnect_enabled = false;
       this._logger.info("disabled ws connection");
     } else {
       await this.reconnect_ws();
     }
     if (this.options().useCookie) {
       const client = this._client;
-      const url = urlJoin(this.datasetApiUrl, "security", "check?set_cookie=true");
+      const url = (0, import_url_join.default)(this.datasetApiUrl, "security", "check?set_cookie=true");
       const headers2 = {
         Authorization: await this.authorizationHeader()
       };
@@ -12027,37 +12013,68 @@ var DataEndpoint = class extends Endpoint {
     return Promise.resolve(this);
   }
   async reconnect_ws() {
+    if (this._ws_connecting) {
+      return this._ws_connecting;
+    }
+    const connecting = this.open_ws();
+    this._ws_connecting = connecting;
+    try {
+      await connecting;
+    } finally {
+      this._ws_connecting = null;
+    }
+  }
+  async open_ws() {
     if (this._ws) {
-      this._ws.close();
+      this.close_ws(this._ws, "unsubscribe");
       this._ws = null;
     }
     const baseUrl = this.datasetApiUrl?.replace("https://", "wss://").replace("http://", "ws://");
     if (!baseUrl) {
       return;
     }
-    const ws_url = urlJoin(baseUrl, "events");
+    const ws_url = (0, import_url_join.default)(baseUrl, "events");
     this._requestLogger.debug("about to connect ws to: %s", ws_url);
     return new Promise((resolve, reject) => {
+      let settled = false;
+      const settle_ok = () => {
+        settled = true;
+        resolve();
+      };
+      const settle_err = (error) => {
+        settled = true;
+        reject(error);
+      };
       const ws = createWebSocket(ws_url);
       if (!ws) {
-        return resolve();
+        return settle_ok();
       }
       this._ws = ws;
-      ws.onopen = async () => {
-        const auth_header = await this.authorizationHeader();
-        let msg = JSON.stringify({ authorization: auth_header });
-        this._requestLogger.debug("ws send: %s", msg);
-        ws.send(msg);
-        msg = JSON.stringify({ subscribe: { account_uuid: this._accountId } });
-        this._requestLogger.debug("ws send: %s", msg);
-        ws.send(msg);
-        for (let dataset_uuid in this._dataset_uuid_to_event_handlers.keys()) {
-          const msg2 = JSON.stringify({ subscribe: { dataset_uuid } });
-          this._requestLogger.debug("ws send: %s", msg2);
-          ws.send(msg2);
-        }
-        this._ws_current_reconnect_delay = WS_INITIAL_RECONNECT_DELAY;
-        resolve();
+      ws.onopen = () => {
+        void this.authorizationHeader().then((auth_header) => {
+          if (this._ws !== ws) {
+            this.close_ws(ws, "unsubscribe");
+            settle_ok();
+            return;
+          }
+          let msg = JSON.stringify({ authorization: auth_header });
+          this._requestLogger.debug("ws send: %s", msg);
+          ws.send(msg);
+          msg = JSON.stringify({ subscribe: { account_uuid: this._accountId } });
+          this._requestLogger.debug("ws send: %s", msg);
+          ws.send(msg);
+          for (const dataset_uuid of this._dataset_uuid_to_event_handlers.keys()) {
+            const msg2 = JSON.stringify({ subscribe: { dataset_uuid } });
+            this._requestLogger.debug("ws send: %s", msg2);
+            ws.send(msg2);
+          }
+          this._ws_current_reconnect_delay = WS_INITIAL_RECONNECT_DELAY;
+          this._ws_reconnect_enabled = true;
+          settle_ok();
+        }).catch((error) => {
+          this.close_ws(ws, "authorization failed", 1011);
+          settle_err(error);
+        });
       };
       ws.onmessage = (event) => {
         const data = JSON.parse(event.data);
@@ -12068,24 +12085,54 @@ var DataEndpoint = class extends Endpoint {
       ws.onclose = (event) => {
         const { code, reason } = event;
         this._requestLogger.debug("ws closed: %d %s", code, reason);
-        if (reason !== "unsubscribe") {
-          if (!this._ws_current_reconnect_delay) {
-            this._ws_current_reconnect_delay = WS_INITIAL_RECONNECT_DELAY;
-          } else if (this._ws_current_reconnect_delay < WS_MAX_RECONNECT_DELAY) {
-            this._ws_current_reconnect_delay *= 1.5;
-          }
-          setTimeout(async () => {
-            await this.reconnect_ws();
-          }, this._ws_current_reconnect_delay);
+        if (!settled) {
+          settle_err(new EyePopDataWebSocketError(ws_url, new Error(`closed before the connection was established: ${code} ${reason}`)));
+        }
+        if (this._ws !== ws) {
+          return;
         }
+        this._ws = null;
+        this.schedule_ws_reconnect();
       };
       ws.onerror = (event) => {
-        this._logger.error(event);
-        reject(event);
+        const error = new EyePopDataWebSocketError(ws_url, event);
+        this._logger.error({ err: error }, "dataset event WebSocket connection failed");
+        settle_err(error);
         return null;
       };
     });
   }
+  close_ws(ws, reason, code = 1e3) {
+    try {
+      ws.close(code, reason);
+    } catch (e) {
+      this._logger.warn({ err: e }, "ignored exception closing the dataset event WebSocket");
+    }
+  }
+  schedule_ws_reconnect() {
+    if (!this._ws_reconnect_enabled || this._ws_reconnect_timeout) {
+      return;
+    }
+    if (!this._ws_current_reconnect_delay) {
+      this._ws_current_reconnect_delay = WS_INITIAL_RECONNECT_DELAY;
+    } else if (this._ws_current_reconnect_delay < WS_MAX_RECONNECT_DELAY) {
+      this._ws_current_reconnect_delay *= 1.5;
+    }
+    this._ws_reconnect_timeout = setTimeout(() => {
+      if (!this._ws_reconnect_enabled) {
+        this._ws_reconnect_timeout = null;
+        return;
+      }
+      void this.reconnect_ws().catch((error) => {
+        this._requestLogger.debug("dataset event WebSocket reconnect failed: %s", error);
+      }).finally(() => {
+        this._ws_reconnect_timeout = null;
+        if (!this._ws) {
+          this.schedule_ws_reconnect();
+        }
+      });
+    }, this._ws_current_reconnect_delay);
+  }
   options() {
     return this._options;
   }
@@ -12110,7 +12157,7 @@ var DataEndpoint = class extends Endpoint {
         body: options.body
       };
       this._requestLogger.debug("Request - " + ri.method + " " + path2 + " BODY: " + (ri.body ? ri.body : ""));
-      return await client.fetch(urlJoin(baseUrl ?? "", path2), ri);
+      return await client.fetch((0, import_url_join.default)(baseUrl ?? "", path2), ri);
     });
     if (response.status === 204) {
       return null;
@@ -12757,6 +12804,97 @@ var DataEndpoint = class extends Endpoint {
   }
 };
 
+// depth.ts
+var isLittleEndianPlatform = new Uint8Array(new Uint16Array([1]).buffer)[0] === 1;
+function base64ToBytes(base64) {
+  if (typeof Buffer !== "undefined") {
+    const buffer = Buffer.from(base64, "base64");
+    return new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+  }
+  const binary = atob(base64);
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) {
+    bytes[i] = binary.charCodeAt(i);
+  }
+  return bytes;
+}
+var DepthMap = class {
+  constructor(width, height, values) {
+    this.width = width;
+    this.height = height;
+    this.values = values;
+  }
+  /**
+   * The depth value at map pixel (x, y), or - when sourceWidth/sourceHeight
+   * are given - at source frame coordinate (x, y) mapped proportionally.
+   * Returns +Infinity for sky pixels.
+   */
+  at(x, y, sourceWidth, sourceHeight) {
+    let mapX = x;
+    let mapY = y;
+    if (sourceWidth && sourceHeight) {
+      mapX = x * this.width / sourceWidth;
+      mapY = y * this.height / sourceHeight;
+    }
+    const clampedX = Math.min(Math.max(Math.floor(mapX), 0), this.width - 1);
+    const clampedY = Math.min(Math.max(Math.floor(mapY), 0), this.height - 1);
+    return this.values[clampedY * this.width + clampedX];
+  }
+  isSky(x, y, sourceWidth, sourceHeight) {
+    return this.at(x, y, sourceWidth, sourceHeight) === Number.POSITIVE_INFINITY;
+  }
+  /** The smallest finite depth value, or undefined if the whole map is sky. */
+  get finiteMin() {
+    this.computeFiniteRange();
+    return this._finiteMin;
+  }
+  /** The largest finite depth value, or undefined if the whole map is sky. */
+  get finiteMax() {
+    this.computeFiniteRange();
+    return this._finiteMax;
+  }
+  computeFiniteRange() {
+    if (this._finiteMin !== void 0 || this._finiteMax !== void 0) {
+      return;
+    }
+    let min = Number.POSITIVE_INFINITY;
+    let max = Number.NEGATIVE_INFINITY;
+    for (let i = 0; i < this.values.length; i++) {
+      const value = this.values[i];
+      if (Number.isFinite(value)) {
+        if (value < min) min = value;
+        if (value > max) max = value;
+      }
+    }
+    if (max >= min) {
+      this._finiteMin = min;
+      this._finiteMax = max;
+    }
+  }
+};
+function decodeDepthMap(depth) {
+  if (!Number.isSafeInteger(depth.width) || depth.width <= 0 || !Number.isSafeInteger(depth.height) || depth.height <= 0 || !Number.isSafeInteger(depth.width * depth.height * 4)) {
+    throw new Error(`invalid depth dimensions: ${depth.width}x${depth.height}`);
+  }
+  const bytes = base64ToBytes(depth.values);
+  const count = depth.width * depth.height;
+  if (bytes.byteLength !== count * 4) {
+    throw new Error(`depth values hold ${bytes.byteLength} bytes, expected ${count * 4} for ${depth.width}x${depth.height} float32`);
+  }
+  let values;
+  if (isLittleEndianPlatform) {
+    const aligned = new Uint8Array(bytes);
+    values = new Float32Array(aligned.buffer, 0, count);
+  } else {
+    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    values = new Float32Array(count);
+    for (let i = 0; i < count; i++) {
+      values[i] = view.getFloat32(i * 4, true);
+    }
+  }
+  return new DepthMap(depth.width, depth.height, values);
+}
+
 // worker/webrtc_whep.ts
 var WebrtcWhep = class extends WebrtcBase {
   constructor(ingressId, getSession, client, requestLogger) {
@@ -12991,11 +13129,13 @@ var index_default = EyePop;
   DEFAULT_PREDICTION_VERSION,
   DataApiType,
   DataEndpoint,
+  DepthMap,
   Endpoint,
   EndpointState,
   EvaluationStatus,
   ExportedBy,
   EyePop,
+  EyePopDataWebSocketError,
   EyepopLineDecoder,
   ForwardOperatorType,
   InferenceType,
@@ -13031,6 +13171,7 @@ var index_default = EyePop;
   WorkflowPhase,
   accessTokenCredential,
   apiKeyCredential,
+  decodeDepthMap,
   encodeMultipartFormData,
   getBaseUrl,
   randomMultipartBoundary,