@eyepop.ai/eyepop 0.20.1 → 0.21.0

package/dist/eyepop.index.mjs

@@ -8638,7 +8638,6 @@ var EndpointState = /* @__PURE__ */ ((EndpointState2) => {
   EndpointState2["Busy"] = "Busy";
   EndpointState2["Authenticating"] = "Authenticating";
   EndpointState2["FetchConfig"] = "FetchConfig";
-  EndpointState2["StartingPop"] = "StartingPop";
   EndpointState2["Error"] = "Error";
   return EndpointState2;
 })(EndpointState || {});
@@ -8881,7 +8880,7 @@ function readableStreamAsyncIterable(stream) {
   };
 }
 
-// jobs.ts
+// worker/jobs.ts
 var AbstractJob = class {
   constructor(params, getSession, client, requestLogger) {
     this._responseStream = null;
@@ -8968,6 +8967,9 @@ var UploadJob = class extends AbstractJob {
   }
   async startJob() {
     const session = await this._getSession();
+    if (!session.baseUrl) {
+      return Promise.reject("session.baseUrl must not ne null");
+    }
     const postUrl = `${session.baseUrl.replace(/\/+$/, "")}/pipelines/${session.pipelineId}/source?mode=queue&processing=sync`;
     let response;
     if (this._params) {
@@ -9021,12 +9023,15 @@ var LoadFromJob = class extends AbstractJob {
     return "loadFromJob";
   }
   async startJob() {
+    const session = await this._getSession();
+    if (!session.baseUrl) {
+      return Promise.reject("session.baseUrl must not ne null");
+    }
     const body = {
       "sourceType": "URL",
       "url": this._location,
       "params": this._params
     };
-    const session = await this._getSession();
     const headers = {
       "Authorization": `Bearer ${session.accessToken}`,
       "Accept": "application/jsonl",
@@ -9055,12 +9060,15 @@ var LoadLiveIngressJob = class extends AbstractJob {
     return "loadLiveIngressJob";
   }
   async startJob() {
+    const session = await this._getSession();
+    if (!session.baseUrl) {
+      return Promise.reject("session.baseUrl must not ne null");
+    }
     const body = {
       "sourceType": "LIVE_INGRESS",
       "liveIngressId": this._ingressId,
       "params": this._params
     };
-    const session = await this._getSession();
     const headers = {
       "Authorization": `Bearer ${session.accessToken}`,
       "Accept": "application/jsonl",
@@ -9081,173 +9089,6 @@ var LoadLiveIngressJob = class extends AbstractJob {
   }
 };
 
-// shims/http_client.ts
-var createHttpClient;
-if ("document" in globalThis && "implementation" in globalThis.document) {
-  class HttpClient2 {
-    constructor() {
-    }
-    async fetch(input, init) {
-      return fetch(input, init);
-    }
-    async close() {
-    }
-  }
-  createHttpClient = async () => {
-    return new HttpClient2();
-  };
-} else {
-  class HttpClient2 {
-    constructor(agent) {
-      this.agent = agent;
-    }
-    async fetch(input, init) {
-      init || (init = {});
-      init.dispatcher = this.agent;
-      return fetch(input, init);
-    }
-    async close() {
-      return this.agent.close();
-    }
-  }
-  createHttpClient = async () => {
-    const undici = __require("undici");
-    const agent = new undici.Agent({
-      keepAliveTimeout: 1e4,
-      connections: 5
-    });
-    return new HttpClient2(agent);
-  };
-}
-
-// semaphore.ts
-var Semaphore = class {
-  /**
-   * Creates a semaphore.
-   * @param permits  The number of permits, i.e. strands of execution being allowed
-   * to run in parallel.
-   * This number can be initialized with a negative integer.
-   */
-  constructor(permits) {
-    this.promiseResolverQueue = [];
-    this.permits = permits;
-  }
-  /**
-   * Returns the number of available permits.
-   * @returns  The number of available permits.
-   */
-  getPermits() {
-    return this.permits;
-  }
-  /**
-   * Returns a promise used to wait for a permit to become available. This method should be awaited on.
-   * @returns  A promise that gets resolved when execution is allowed to proceed.
-   */
-  async wait() {
-    if (this.permits > 0) {
-      this.permits -= 1;
-      return Promise.resolve(true);
-    }
-    return new Promise((resolver) => this.promiseResolverQueue.push(resolver));
-  }
-  /**
-   * Alias for {@linkcode Semaphore.wait}.
-   * @returns  A promise that gets resolved when execution is allowed to proceed.
-   */
-  async acquire() {
-    return this.wait();
-  }
-  /**
-   * Same as {@linkcode Semaphore.wait} except the promise returned gets resolved with false if no
-   * permit becomes available in time.
-   * @param milliseconds  The time spent waiting before the wait is aborted. This is a lower bound,
-   * you shouldn't rely on it being precise.
-   * @returns  A promise that gets resolved to true when execution is allowed to proceed or
-   * false if the time given elapses before a permit becomes available.
-   */
-  async waitFor(milliseconds) {
-    if (this.permits > 0) {
-      this.permits -= 1;
-      return Promise.resolve(true);
-    }
-    let resolver = (b) => void 0;
-    const promise = new Promise((r) => {
-      resolver = r;
-    });
-    this.promiseResolverQueue.push(resolver);
-    setTimeout(() => {
-      const index = this.promiseResolverQueue.indexOf(resolver);
-      if (index !== -1) {
-        this.promiseResolverQueue.splice(index, 1);
-      } else {
-        console.warn(`Semaphore.waitFor couldn't find its promise resolver in the queue`);
-      }
-      resolver(false);
-    }, milliseconds);
-    return promise;
-  }
-  /**
-   * Synchronous function that tries to acquire a permit and returns true if successful, false otherwise.
-   * @returns  Whether a permit could be acquired.
-   */
-  tryAcquire() {
-    if (this.permits > 0) {
-      this.permits -= 1;
-      return true;
-    }
-    return false;
-  }
-  /**
-   * Acquires all permits that are currently available and returns the number of acquired permits.
-   * @returns  Number of acquired permits.
-   */
-  drainPermits() {
-    if (this.permits > 0) {
-      const permitCount = this.permits;
-      this.permits = 0;
-      return permitCount;
-    }
-    return 0;
-  }
-  /**
-   * Increases the number of permits by one. If there are other functions waiting, one of them will
-   * continue to execute in a future iteration of the event loop.
-   */
-  signal() {
-    this.permits += 1;
-    if (this.permits > 1 && this.promiseResolverQueue.length > 0) {
-      console.warn("Semaphore.permits should never be > 0 when there is someone waiting.");
-    } else if (this.permits === 1 && this.promiseResolverQueue.length > 0) {
-      this.permits -= 1;
-      const nextResolver = this.promiseResolverQueue.shift();
-      if (nextResolver) {
-        nextResolver(true);
-      }
-    }
-  }
-  /**
-   * Alias for {@linkcode Semaphore.signal}.
-   */
-  release() {
-    this.signal();
-  }
-  /**
-   * Schedules func to be called once a permit becomes available.
-   * Returns a promise that resolves to the return value of func.
-   * @typeparam T  The return type of func.
-   * @param func  The function to be executed.
-   * @return  A promise that gets resolved with the return value of the function.
-   */
-  async execute(func) {
-    await this.wait();
-    try {
-      return await func();
-    } finally {
-      this.signal();
-    }
-  }
-};
-
 // ../../node_modules/uuid/dist/esm-node/rng.js
 import crypto from "crypto";
 var rnds8Pool = new Uint8Array(256);
@@ -9295,7 +9136,7 @@ function v4(options, buf, offset) {
 }
 var v4_default = v4;
 
-// webrtc_base.ts
+// worker/webrtc_base.ts
 import path from "path";
 var WebrtcBase = class _WebrtcBase {
   constructor(getSession, client, ingressId, urlBasePath, requestLogger) {
@@ -9536,7 +9377,7 @@ var WebrtcBase = class _WebrtcBase {
   }
 };
 
-// webrtc_whip.ts
+// worker/webrtc_whip.ts
 var WebrtcWhip = class extends WebrtcBase {
   constructor(stream, getSession, client, requestLogger) {
     super(getSession, client, v4_default().toString(), "/liveIngress/whip", requestLogger);
@@ -9622,7 +9463,7 @@ var WebrtcWhip = class extends WebrtcBase {
   }
 };
 
-// webrtc_whep.ts
+// worker/webrtc_whep.ts
 var WebrtcWhep = class extends WebrtcBase {
   constructor(ingressId, getSession, client, requestLogger) {
     super(getSession, client, ingressId, "/liveIngress/whep", requestLogger);
@@ -9728,89 +9569,489 @@ if ("document" in globalThis && "implementation" in globalThis.document) {
   };
 }
 
-// endpoint.ts
-import { pino } from "pino";
-
-// shims/browser_session.ts
-import { createAuth0Client } from "@auth0/auth0-spa-js";
-var authenticateBrowserSession;
+// shims/http_client.ts
+var createHttpClient;
 if ("document" in globalThis && "implementation" in globalThis.document) {
-  authenticateBrowserSession = async (auth0, eyepopUrl, popId) => {
-    const options = {
-      clientId: auth0.clientId,
-      domain: auth0.domain,
-      authorizationParams: {
-        scope: auth0.scope,
-        audience: auth0.audience
-      }
-    };
-    const auth0Client = await createAuth0Client(options);
-    if (!await auth0Client.isAuthenticated()) {
-      await auth0Client.loginWithPopup();
+  class HttpClient2 {
+    constructor() {
     }
-    const accessToken = await auth0Client.getTokenSilently();
-    if (!accessToken) {
-      return Promise.reject("auth0 login failed");
+    async fetch(input, init) {
+      return fetch(input, init);
     }
-    const session = {
-      eyepopUrl,
-      popId,
-      accessToken,
-      validUntil: Date.now() + 60 * 60 * 1e3
-    };
-    return session;
+    async close() {
+    }
+  }
+  createHttpClient = async () => {
+    return new HttpClient2();
   };
 } else {
-  authenticateBrowserSession = (auth0, eyepopUrl, popId) => {
-    return Promise.reject("auth0 login not supported server-side");
-  };
-}
-
-// endpoint.ts
-var Endpoint = class {
-  constructor(options) {
-    this._options = options;
-    this._baseUrl = null;
-    this._pipelineId = null;
-    this._popName = null;
-    this._token = null;
-    this._expire_token_time = null;
-    this._client = null;
-    this._state = "Idle" /* Idle */;
-    this._pipeline = null;
-    this._stateChangeHandler = null;
-    this._ingressEventHandler = null;
-    this._ingressEventWs = null;
-    this._sandboxId = null;
-    const sessionAuth = options.auth;
-    if (sessionAuth.session !== void 0) {
-      const sessionPlus = sessionAuth.session;
-      if (sessionPlus.sandboxId) {
-        this._sandboxId = sessionPlus.sandboxId;
-      }
+  class HttpClient2 {
+    constructor(agent) {
+      this.agent = agent;
     }
-    this._limit = new Semaphore(this._options.jobQueueLength ?? 1024);
-    let rootLogger;
-    if (options.logger) {
-      rootLogger = options.logger;
-    } else {
-      rootLogger = pino();
+    async fetch(input, init) {
+      init || (init = {});
+      init.dispatcher = this.agent;
+      return fetch(input, init);
     }
-    this._logger = rootLogger.child({ module: "eyepop" });
-    this._requestLogger = this._logger.child({ module: "requests" });
-  }
-  eyepopUrl() {
-    if (this._options.eyepopUrl) {
-      return this._options.eyepopUrl.replace(/\/+$/, "");
-    } else {
-      return "https://api.eyepop.ai";
+    async close() {
+      return this.agent.close();
     }
   }
-  state() {
-    return this._state;
-  }
-  pendingJobs() {
-    return (this._options.jobQueueLength ?? 1024) - this._limit.getPermits();
+  createHttpClient = async () => {
+    const undici = __require("undici");
+    const agent = new undici.Agent({
+      keepAliveTimeout: 1e4,
+      connections: 5
+    });
+    return new HttpClient2(agent);
+  };
+}
+
+// semaphore.ts
+var Semaphore = class {
+  /**
+   * Creates a semaphore.
+   * @param permits  The number of permits, i.e. strands of execution being allowed
+   * to run in parallel.
+   * This number can be initialized with a negative integer.
+   */
+  constructor(permits) {
+    this.promiseResolverQueue = [];
+    this.permits = permits;
+  }
+  /**
+   * Returns the number of available permits.
+   * @returns  The number of available permits.
+   */
+  getPermits() {
+    return this.permits;
+  }
+  /**
+   * Returns a promise used to wait for a permit to become available. This method should be awaited on.
+   * @returns  A promise that gets resolved when execution is allowed to proceed.
+   */
+  async wait() {
+    if (this.permits > 0) {
+      this.permits -= 1;
+      return Promise.resolve(true);
+    }
+    return new Promise((resolver) => this.promiseResolverQueue.push(resolver));
+  }
+  /**
+   * Alias for {@linkcode Semaphore.wait}.
+   * @returns  A promise that gets resolved when execution is allowed to proceed.
+   */
+  async acquire() {
+    return this.wait();
+  }
+  /**
+   * Same as {@linkcode Semaphore.wait} except the promise returned gets resolved with false if no
+   * permit becomes available in time.
+   * @param milliseconds  The time spent waiting before the wait is aborted. This is a lower bound,
+   * you shouldn't rely on it being precise.
+   * @returns  A promise that gets resolved to true when execution is allowed to proceed or
+   * false if the time given elapses before a permit becomes available.
+   */
+  async waitFor(milliseconds) {
+    if (this.permits > 0) {
+      this.permits -= 1;
+      return Promise.resolve(true);
+    }
+    let resolver = (b) => void 0;
+    const promise = new Promise((r) => {
+      resolver = r;
+    });
+    this.promiseResolverQueue.push(resolver);
+    setTimeout(() => {
+      const index = this.promiseResolverQueue.indexOf(resolver);
+      if (index !== -1) {
+        this.promiseResolverQueue.splice(index, 1);
+      } else {
+        console.warn(`Semaphore.waitFor couldn't find its promise resolver in the queue`);
+      }
+      resolver(false);
+    }, milliseconds);
+    return promise;
+  }
+  /**
+   * Synchronous function that tries to acquire a permit and returns true if successful, false otherwise.
+   * @returns  Whether a permit could be acquired.
+   */
+  tryAcquire() {
+    if (this.permits > 0) {
+      this.permits -= 1;
+      return true;
+    }
+    return false;
+  }
+  /**
+   * Acquires all permits that are currently available and returns the number of acquired permits.
+   * @returns  Number of acquired permits.
+   */
+  drainPermits() {
+    if (this.permits > 0) {
+      const permitCount = this.permits;
+      this.permits = 0;
+      return permitCount;
+    }
+    return 0;
+  }
+  /**
+   * Increases the number of permits by one. If there are other functions waiting, one of them will
+   * continue to execute in a future iteration of the event loop.
+   */
+  signal() {
+    this.permits += 1;
+    if (this.permits > 1 && this.promiseResolverQueue.length > 0) {
+      console.warn("Semaphore.permits should never be > 0 when there is someone waiting.");
+    } else if (this.permits === 1 && this.promiseResolverQueue.length > 0) {
+      this.permits -= 1;
+      const nextResolver = this.promiseResolverQueue.shift();
+      if (nextResolver) {
+        nextResolver(true);
+      }
+    }
+  }
+  /**
+   * Alias for {@linkcode Semaphore.signal}.
+   */
+  release() {
+    this.signal();
+  }
+  /**
+   * Schedules func to be called once a permit becomes available.
+   * Returns a promise that resolves to the return value of func.
+   * @typeparam T  The return type of func.
+   * @param func  The function to be executed.
+   * @return  A promise that gets resolved with the return value of the function.
+   */
+  async execute(func) {
+    await this.wait();
+    try {
+      return await func();
+    } finally {
+      this.signal();
+    }
+  }
+};
+
+// endpoint.ts
+import { pino } from "pino";
+
+// shims/browser_session.ts
+import { createAuth0Client } from "@auth0/auth0-spa-js";
+var authenticateBrowserSession;
+if ("document" in globalThis && "implementation" in globalThis.document) {
+  authenticateBrowserSession = async (auth0, options) => {
+    if (options.eyepopUrl == null) {
+      return Promise.reject("options.eyepopUrl cannot be null");
+    }
+    const auth0ClientOptions = {
+      clientId: auth0.clientId,
+      domain: auth0.domain,
+      authorizationParams: {
+        scope: auth0.scope,
+        audience: auth0.audience
+      }
+    };
+    const auth0Client = await createAuth0Client(auth0ClientOptions);
+    if (!await auth0Client.isAuthenticated()) {
+      await auth0Client.loginWithPopup();
+    }
+    const accessToken = await auth0Client.getTokenSilently();
+    if (!accessToken) {
+      return Promise.reject("auth0 login failed");
+    }
+    let session;
+    const workerOptions = options;
+    if (typeof workerOptions.popId != "undefined") {
+      const workerSession = {
+        eyepopUrl: options.eyepopUrl,
+        accessToken,
+        validUntil: Date.now() + 60 * 60 * 1e3,
+        popId: workerOptions.popId,
+        baseUrl: void 0,
+        pipelineId: void 0,
+        sandboxId: void 0
+      };
+      session = workerSession;
+    } else {
+      session = {
+        eyepopUrl: options.eyepopUrl,
+        accessToken,
+        validUntil: Date.now() + 60 * 60 * 1e3
+      };
+    }
+    return session;
+  };
+} else {
+  authenticateBrowserSession = (auth0, options) => {
+    return Promise.reject("auth0 login not supported server-side");
+  };
+}
+
+// endpoint.ts
+var Endpoint = class {
+  constructor(options) {
+    this._options = options;
+    this._token = null;
+    this._expire_token_time = null;
+    this._client = null;
+    this._statusRetryHandlers = /* @__PURE__ */ new Map();
+    this._statusRetryHandlers.set(401, this.statusHandler401);
+    this._limit = new Semaphore(this._options.jobQueueLength ?? 1024);
+    this._state = "Idle" /* Idle */;
+    this._stateChangeHandler = null;
+    let rootLogger;
+    if (options.logger) {
+      rootLogger = options.logger;
+    } else {
+      rootLogger = pino();
+    }
+    this._logger = rootLogger.child({ module: "eyepop" });
+    this._requestLogger = this._logger.child({ module: "requests" });
+  }
+  setStatusRetryHandlers(statusRetryHandlers = void 0) {
+    this._statusRetryHandlers = new Map(statusRetryHandlers);
+    this._statusRetryHandlers.set(401, this.statusHandler401);
+  }
+  eyepopUrl() {
+    if (this._options.eyepopUrl) {
+      return this._options.eyepopUrl.replace(/\/+$/, "");
+    } else {
+      return "https://api.eyepop.ai";
+    }
+  }
+  pendingJobs() {
+    return (this._options.jobQueueLength ?? 1024) - this._limit.getPermits();
+  }
+  state() {
+    return this._state;
+  }
+  onStateChanged(handler) {
+    this._stateChangeHandler = handler;
+    return this;
+  }
+  updateState(newState = void 0) {
+    const fromState = this._state;
+    if (newState == void 0) {
+      if (this._limit.getPermits() == this._options.jobQueueLength) {
+        newState = "Idle" /* Idle */;
+      } else {
+        newState = "Busy" /* Busy */;
+      }
+    }
+    this._state = newState;
+    if (this._stateChangeHandler) {
+      this._stateChangeHandler(fromState, this._state);
+    }
+  }
+  async connect() {
+    if (this._client) {
+      this._logger.warn("endpoint already connected");
+      return this;
+    }
+    if (!this._options.eyepopUrl) {
+      return Promise.reject("option eyepopUrl or environment variable EYEPOP_URL is required");
+    }
+    if (this._options.auth === void 0) {
+      return Promise.reject("cannot connect without defined auth option");
+    }
+    if (this._options.auth.session !== void 0) {
+      this._token = this._options.auth.session.accessToken;
+      this._expire_token_time = this._options.auth.session.validUntil / 1e3;
+    } else if (this._options.auth.oAuth2 !== void 0) {
+    } else if (this._options.auth.secretKey !== void 0) {
+    } else {
+      return Promise.reject("option secretKey or environment variable EYEPOP_SECRET_KEY is required");
+    }
+    this._client = await createHttpClient();
+    return await this.reconnect();
+  }
+  async disconnect(wait = true) {
+    if (wait && this._limit) {
+      for (let j = 0; j < this._options.jobQueueLength; j++) {
+        await this._limit.acquire();
+      }
+    }
+    this._limit = new Semaphore(this._options.jobQueueLength ?? 1024);
+    if (this._client) {
+      await this._client.close();
+      this._client = null;
+    }
+  }
+  async session() {
+    await this.currentAccessToken();
+    if (this._token == null || this._expire_token_time == null) {
+      return Promise.reject("endpoint not connected");
+    }
+    return {
+      eyepopUrl: this._options.eyepopUrl,
+      accessToken: this._token,
+      validUntil: this._expire_token_time * 1e3
+    };
+  }
+  statusHandler401(statusCode) {
+    this._token = null;
+    this._expire_token_time = null;
+  }
+  async fetchWithRetry(fetcher, retries = 1) {
+    while (true) {
+      try {
+        const response = await fetcher();
+        if (response.status <= 300) {
+          return response;
+        } else {
+          const handler = this._statusRetryHandlers.get(response.status);
+          if (handler != null) {
+            handler(response.status);
+            if (retries--) {
+              this._requestLogger.info("received %d response, retry", response.status);
+            } else {
+              return Promise.reject(`response ${response.status}: ${response.statusText}`);
+            }
+          } else {
+            return Promise.reject(`response ${response.status}: ${response.statusText}`);
+          }
+        }
+      } catch (error) {
+        const handler = this._statusRetryHandlers.get(404);
+        if (handler != null) {
+          handler(error);
+          if (retries--) {
+            this._requestLogger.info("error %s, retry", error);
+          } else {
+            return Promise.reject(`error ${error}`);
+          }
+        } else {
+          return Promise.reject(`error ${error}`);
+        }
+      }
+    }
+  }
+  async reconnect() {
+    throw new Error("reconnect() not implemented");
+  }
+  async authorizationHeader() {
+    return `Bearer ${await this.currentAccessToken()}`;
+  }
+  async currentAccessToken() {
+    const now = Date.now() / 1e3;
+    if (!this._token || this._expire_token_time < now) {
+      this.updateState("Authenticating" /* Authenticating */);
+      try {
+        if (!this._client) {
+          return Promise.reject("endpoint not connected");
+        } else if (this._options.auth.session !== void 0) {
+          return Promise.reject("temporary access token expired");
+        } else if (this._options.auth.oAuth2 !== void 0 && this._options.eyepopUrl) {
+          const session = await authenticateBrowserSession(this._options.auth.oAuth2, this._options);
+          this._token = session.accessToken;
+          this._expire_token_time = session.validUntil / 1e3;
+        } else if (this._options.auth.secretKey !== void 0 && this._options.eyepopUrl) {
+          const secretKeyAuth = this._options.auth;
+          const body = { "secret_key": secretKeyAuth.secretKey };
+          const headers = { "Content-Type": "application/json" };
+          const post_url = `${this.eyepopUrl()}/authentication/token`;
+          this._requestLogger.debug("before POST %s", post_url);
+          const response = await this._client.fetch(post_url, {
+            method: "POST",
+            headers,
+            body: JSON.stringify(body)
+          });
+          if (response.status != 200) {
+            const message = await response.text();
+            return Promise.reject(`Unexpected status ${response.status}: ${message}`);
+          }
+          this._requestLogger.debug("after POST %s", post_url);
+          const data = await response.json();
+          const token = data;
+          this._token = token.access_token;
+          this._expire_token_time = now + token.expires_in - 60;
+        } else {
+          return Promise.reject("no valid auth option");
+        }
+      } finally {
+        this.updateState();
+      }
+    }
+    this._logger.debug("using access token, valid for at least %d seconds", this._expire_token_time - now);
+    return this._token;
+  }
+};
+
+// worker/worker_options.ts
+var TransientPopId = /* @__PURE__ */ ((TransientPopId2) => {
+  TransientPopId2["Transient"] = "transient";
+  return TransientPopId2;
+})(TransientPopId || {});
+
+// worker/worker_endpoint.ts
+var WorkerEndpoint = class extends Endpoint {
+  constructor(options) {
+    super(options);
+    this.setStatusRetryHandlers(/* @__PURE__ */ new Map([[404, (statusCode) => this.statusHandler404(statusCode)]]));
+    this._baseUrl = null;
+    this._pipelineId = null;
+    this._popName = null;
+    this._pipeline = null;
+    this._ingressEventHandler = null;
+    this._ingressEventWs = null;
+    this._sandboxId = null;
+    const sessionAuth = options.auth;
+    if (sessionAuth.session !== void 0) {
+      const workerSession = sessionAuth.session;
+      if (workerSession.sandboxId) {
+        this._sandboxId = workerSession.sandboxId;
+        this.options().isSandbox = true;
+      }
+    }
+  }
+  options() {
+    return this._options;
+  }
+  async disconnect(wait = true) {
+    if (this._sandboxId && this._baseUrl) {
+      const sandboxUrl = `${this._baseUrl}/sandboxes/${this._sandboxId}`;
+      const headers = {
+        "Authorization": await this.authorizationHeader()
+      };
+      this._requestLogger.debug("before DELETE %s", sandboxUrl);
+      let response = await this._client?.fetch(sandboxUrl, {
+        method: "DELETE",
+        headers
+      });
+      this._requestLogger.debug("after DELETE %s", sandboxUrl);
+      if (response?.status != 204) {
+        const message = await response?.text();
+        return Promise.reject(`disconnecting sandbox failed, status ${response?.status}: ${message}`);
+      }
+      this._sandboxId = null;
+    }
+    return super.disconnect(wait);
+  }
+  statusHandler404(statusCode) {
+    this._pipelineId = null;
+    this._baseUrl = null;
+  }
+  async session() {
+    const session = await super.session();
+    if (this._baseUrl == null || this._pipelineId == null) {
+      await this.reconnect();
+      if (this._baseUrl == null || this._pipelineId == null) {
+        return Promise.reject("endpoint not connected");
+      }
+    }
+    return {
+      eyepopUrl: session.eyepopUrl,
+      accessToken: session.accessToken,
+      validUntil: session.validUntil,
+      popId: this.options().popId,
+      baseUrl: this._baseUrl,
+      pipelineId: this._pipelineId,
+      sandboxId: this._sandboxId ?? void 0
+    };
   }
   popName() {
     return this._popName;
@@ -9891,105 +10132,15 @@ var Endpoint = class {
     }
   }
   popId() {
-    return this._options.popId || null;
-  }
-  onStateChanged(handler) {
-    this._stateChangeHandler = handler;
-    return this;
+    return this.options().popId || null;
   }
   onIngressEvent(handler) {
     this._ingressEventHandler = handler;
     this.startIngressWs().then(() => {
-    }).catch((reason) => {
-      this._logger.warn("unexpected error starting the ingress event handler: %s", reason);
-    });
-    return this;
-  }
-  async connect() {
-    if (this._client) {
-      this._logger.warn("endpoint already connected");
-      return this;
-    }
-    if (!this._options.eyepopUrl) {
-      return Promise.reject("option eyepopUrl or environment variable EYEPOP_URL is required");
-    }
-    if (!this._options.popId) {
-      return Promise.reject("option popId or environment variable EYEPOP_POP_ID is required");
-    }
-    if (this._options.auth === void 0) {
-      return Promise.reject("cannot connect without defined auth option");
-    }
-    if (this._options.auth.session !== void 0) {
-      this._token = this._options.auth.session.accessToken;
-      this._expire_token_time = this._options.auth.session.validUntil / 1e3;
-    } else if (this._options.auth.oAuth2 !== void 0) {
-    } else if (this._options.auth.secretKey !== void 0) {
-    } else {
-      return Promise.reject("option secretKey or environment variable EYEPOP_SECRET_KEY is required");
-    }
-    this._client = await createHttpClient();
-    const client = this._client;
-    let result = await this.reconnect();
-    if (this._baseUrl && this._options.stopJobs) {
-      const body = { "sourceType": "NONE" };
-      let response = await this.fetchWithRetry(async () => {
-        const session = await this.session();
-        const headers = {
-          "Authorization": `Bearer ${session.accessToken}`,
-          "Content-Type": "application/json"
-        };
-        const stop_url = `${session.baseUrl}/pipelines/${session.pipelineId}/source?mode=preempt&processing=sync`;
-        return client.fetch(stop_url, {
-          method: "PATCH",
-          headers,
-          body: JSON.stringify(body)
-        });
-      });
-      if (response.status >= 300) {
-        const message = await response.text();
-        return Promise.reject(`Unexpected status ${response.status}: ${message}`);
-      }
-    }
-    if (!this._ingressEventWs && this._ingressEventHandler) {
-      await this.startIngressWs();
-    }
-    return result;
-  }
-  async disconnect(wait = true) {
-    if (wait && this._limit) {
-      for (let j = 0; j < this._options.jobQueueLength; j++) {
-        await this._limit.acquire();
-      }
-    }
-    this._limit = new Semaphore(this._options.jobQueueLength ?? 1024);
-    if (this._client) {
-      await this._client.close();
-      this._client = null;
-    }
-    this._baseUrl = null;
-    this._pipelineId = null;
-    this._sandboxId = null;
-  }
-  async session() {
-    await this.currentAccessToken();
-    if (this._token == null || this._expire_token_time == null) {
-      return Promise.reject("endpoint not connected");
-    }
-    if (this._baseUrl == null || this._pipelineId == null) {
-      await this.reconnect();
-      if (this._baseUrl == null || this._pipelineId == null) {
-        return Promise.reject("endpoint not connected");
-      }
-    }
-    return {
-      eyepopUrl: this._options.eyepopUrl,
-      popId: this._options.popId,
-      accessToken: this._token,
-      validUntil: this._expire_token_time * 1e3,
-      baseUrl: this._baseUrl,
-      pipelineId: this._pipelineId,
-      sandboxId: this._sandboxId ?? void 0
-    };
+    }).catch((reason) => {
+      this._logger.warn("unexpected error starting the ingress event handler: %s", reason);
+    });
+    return this;
   }
   async liveIngress(stream) {
     if (!this._baseUrl || !this._client) {
@@ -10024,209 +10175,662 @@ var Endpoint = class {
       return Promise.reject("unknown source type");
     }
   }
-  async startIngressWs() {
+  async startIngressWs() {
+    const client = this._client;
+    if (this._ingressEventWs || !this._baseUrl || !client) {
+      return;
+    }
+    try {
+      const session = await this.session();
+      let response = await this.fetchWithRetry(async () => {
+        const headers = {
+          "Authorization": `Bearer ${session.accessToken}`
+        };
+        const getTokenUrl = `${session.baseUrl}/liveIngress/events/token`;
+        return client.fetch(getTokenUrl, { headers });
+      });
+      if (response.status != 200) {
+        const message = await response.text();
+        return Promise.reject(`Unexpected status ${response.status}: ${message}`);
+      }
+      const wsAuthToken = await response.json();
+      const wsUrl = this._baseUrl.startsWith("https://") ? `${this._baseUrl.replace("https://", "wss://")}/liveIngress/events/${wsAuthToken.token}` : `${this._baseUrl.replace("http://", "ws://")}/liveIngress/events/${wsAuthToken.token}`;
+      this._ingressEventWs = new WebSocket(wsUrl);
+      this._ingressEventWs.addEventListener("message", (event) => {
+        const ingressEvent = JSON.parse(event.data);
+        if (this._ingressEventHandler) {
+          this._ingressEventHandler(ingressEvent);
+        }
+      });
+    } finally {
+      this.updateState();
+    }
+  }
+  async uploadFile(source, params) {
+    if (!this._baseUrl || !this._pipelineId || !this._client || !this._limit) {
+      return Promise.reject("endpoint not connected, use connect() before upload()");
+    }
+    await this._limit.acquire();
+    try {
+      this.updateState();
+      const job = new UploadJob(source.file, source.file.type, params, async () => {
+        return this.session();
+      }, this._client, this._requestLogger);
+      return job.start(() => {
+        this.jobDone(job);
+      }, (statusCode) => {
+        this.jobStatus(job, statusCode);
+      });
+    } catch (e) {
+      this._limit.release();
+      throw e;
+    }
+  }
+  async uploadStream(source, params) {
+    if (!this._baseUrl || !this._pipelineId || !this._client || !this._limit) {
+      return Promise.reject("endpoint not connected, use connect() before upload()");
+    }
+    await this._limit.acquire();
+    try {
+      this.updateState();
+      const job = new UploadJob(source.stream, source.mimeType, params, async () => {
+        return this.session();
+      }, this._client, this._requestLogger);
+      return job.start(() => {
+        this.jobDone(job);
+      }, (statusCode) => {
+        this.jobStatus(job, statusCode);
+      });
+    } catch (e) {
+      this._limit.release();
+      throw e;
+    }
+  }
+  async uploadPath(source, params) {
+    if (!this._baseUrl || !this._pipelineId || !this._client || !this._limit) {
+      throw new Error("endpoint not connected, use connect() before process()");
+    }
+    await this._limit.acquire();
+    try {
+      this.updateState();
+      const streamSource = await resolvePath(source);
+      const job = new UploadJob(streamSource.stream, streamSource.mimeType, params, async () => {
+        return this.session();
+      }, this._client, this._requestLogger);
+      return job.start(() => {
+        this.jobDone(job);
+      }, (statusCode) => {
+        this.jobStatus(job, statusCode);
+      });
+    } catch (e) {
+      this._limit.release();
+      throw e;
+    }
+  }
+  async loadFrom(source, params) {
+    if (!this._baseUrl || !this._pipelineId || !this._client || !this._limit) {
+      throw new Error("endpoint not connected, use connect() before loadFrom()");
+    }
+    await this._limit.acquire();
+    try {
+      this.updateState();
+      const job = new LoadFromJob(source.url, params, async () => {
+        return this.session();
+      }, this._client, this._requestLogger);
+      return job.start(() => {
+        this.jobDone(job);
+      }, (statusCode) => {
+        this.jobStatus(job, statusCode);
+      });
+    } catch (e) {
+      this._limit.release();
+      throw e;
+    }
+  }
+  async loadLiveIngress(source, params) {
+    if (!this._baseUrl || !this._pipelineId || !this._client || !this._limit) {
+      throw new Error("endpoint not connected, use connect() before loadLiveIngress()");
+    }
+    await this._limit.acquire();
+    try {
+      this.updateState();
+      const job = new LoadLiveIngressJob(source.ingressId, params, async () => {
+        return this.session();
+      }, this._client, this._requestLogger);
+      return job.start(() => {
+        this.jobDone(job);
+      }, (statusCode) => {
+        this.jobStatus(job, statusCode);
+      });
+    } catch (e) {
+      this._limit.release();
+      throw e;
+    }
+  }
+  jobDone(job) {
+    this._limit?.release();
+    this.updateState();
+  }
+  jobStatus(job, statusCode) {
+    if (statusCode == 404) {
+      this.statusHandler404(statusCode);
+    } else if (statusCode == 401) {
+      this.statusHandler401(statusCode);
+    }
+  }
+  async reconnect() {
+    if (!this._client) {
+      return Promise.reject("endpoint not initialized");
+    }
+    let config_url;
+    if (this.options().popId == "transient" /* Transient */) {
+      config_url = `${this.eyepopUrl()}/workers/config`;
+    } else {
+      config_url = `${this.eyepopUrl()}/pops/${this.options().popId}/config?auto_start=false`;
+    }
+    const headers = {
+      "Authorization": await this.authorizationHeader()
+    };
+    this.updateState("FetchConfig" /* FetchConfig */);
+    this._requestLogger.debug("before GET %s", config_url);
+    let response = await this._client.fetch(config_url, { headers });
+    if (response.status == 401) {
+      this._requestLogger.debug("after GET %s: 401, about to retry with fresh access token", config_url);
+      this.statusHandler401(response.status);
+      const headers2 = {
+        "Authorization": await this.authorizationHeader()
+      };
+      this.updateState("FetchConfig" /* FetchConfig */);
+      response = await this._client.fetch(config_url, {
+        headers: headers2
+      });
+    }
+    if (response.status != 200) {
+      this.updateState("Error" /* Error */);
+      const message = await response.text();
+      return Promise.reject(`Unexpected status ${response.status}: ${message}`);
+    }
+    let config = await response.json();
+    this._requestLogger.debug("after GET %s", config_url);
+    if (!config.base_url && this.options().autoStart) {
+      const auto_start_config_url = `${this.eyepopUrl()}/pops/${this.options().popId}/config?auto_start=true`;
+      this._requestLogger.debug("pop was not running, trying to autostart with: %s", auto_start_config_url);
+      const headers2 = {
+        "Authorization": await this.authorizationHeader()
+      };
+      response = await this._client.fetch(auto_start_config_url, {
+        headers: headers2
+      });
+      if (response.status != 200) {
+        this.updateState("Error" /* Error */);
+        const message = await response.text();
+        return Promise.reject(`Unexpected status ${response.status}: ${message}`);
+      }
+      config = await response.json();
+    }
+    const baseUrl = new URL(config.base_url, this.eyepopUrl());
+    this._baseUrl = baseUrl.toString();
+    if (this._baseUrl) {
+      this._baseUrl = this._baseUrl.replace(/\/+$/, "");
+      if (this.options().isSandbox && this._sandboxId === null) {
+        const headers3 = {
+          "Authorization": await this.authorizationHeader()
+        };
+        const createSandboxUrl = `${this._baseUrl}/sandboxes`;
+        this._requestLogger.debug("before POST %s", createSandboxUrl);
+        const response3 = await this._client.fetch(createSandboxUrl, {
+          method: "POST",
+          headers: headers3
+        });
+        if (!response3.ok) {
+          const message = await response3.text();
+          return Promise.reject(`Unexpected status ${response3.status}: ${message}`);
+        }
+        const responseJson = await response3.json();
+        this._requestLogger.debug("after POST %s", createSandboxUrl);
+        if (responseJson) {
+          this._sandboxId = responseJson;
+        }
+      }
+      if (this.options().popId == "transient" /* Transient */) {
+        this._pipelineId = await this.startPopLessPipeline();
+        this._popName = this.options().popId || null;
+      } else {
+        this._pipelineId = config.pipeline_id;
+        this._popName = config.name;
+      }
+      if (!this._pipelineId || !this._baseUrl) {
+        return Promise.reject(`Pop not started`);
+      }
+      this._baseUrl = this._baseUrl.replace(/\/+$/, "");
+      const get_url = `${this._baseUrl}/pipelines/${this._pipelineId}`;
+      const headers2 = {
+        "Authorization": await this.authorizationHeader()
+      };
+      this._requestLogger.debug("before GET %s", get_url);
+      let response2 = await this._client.fetch(get_url, {
+        method: "GET",
+        headers: headers2
+      });
+      if (response2.status > 200) {
+        const message = await response2.text();
+        return Promise.reject(`Unexpected status ${response2.status}: ${message}`);
+      }
+      this._requestLogger.debug("after GET %s", get_url);
+      this._pipeline = await response2.json();
+      if (this.options().stopJobs) {
+        const body = { "sourceType": "NONE" };
+        const headers3 = {
+          "Authorization": await this.authorizationHeader()
+        };
+        const stop_url = `${this._baseUrl}/pipelines/${this._pipeline.id}/source?mode=preempt&processing=sync`;
+        let response3 = await this._client.fetch(stop_url, {
+          method: "PATCH",
+          headers: headers3,
+          body: JSON.stringify(body)
+        });
+        if (response3.status >= 300) {
+          const message = await response3.text();
+          return Promise.reject(`Unexpected status ${response3.status}: ${message}`);
+        }
+      }
+    }
+    if (!this._ingressEventWs && this._ingressEventHandler) {
+      await this.startIngressWs();
+    }
+    this.updateState();
+    return Promise.resolve(this);
+  }
+  async startPopLessPipeline() {
+    const client = this._client;
+    const baseUrl = this._baseUrl;
+    const sandboxId = this._sandboxId;
+    if (client == null || baseUrl == null) {
+      return Promise.reject("endpoint not initialized");
+    }
+    let pipeline;
+    if (this._pipeline) {
+      pipeline = this._pipeline.inferPipeline;
+    } else {
+      pipeline = "identity";
+    }
+    let postTransform;
+    if (this._pipeline && this._pipeline.postTransform) {
+      postTransform = this._pipeline.postTransform;
+    } else {
+      postTransform = null;
+    }
+    const body = {
+      "inferPipelineDef": {
+        "pipeline": pipeline
+      },
+      "postTransformDef": {
+        "transform": postTransform
+      },
+      "source": {
+        "sourceType": "NONE"
+      },
+      "idleTimeoutSeconds": 30,
+      "logging": ["out_meta"],
+      "videoOutput": "no_output"
+    };
+    let post_url;
+    if (sandboxId) {
+      post_url = `${baseUrl.replace(/\/+$/, "")}/pipelines?sandboxId=${sandboxId}`;
+    } else {
+      post_url = `${baseUrl.replace(/\/+$/, "")}/pipelines`;
+    }
+    let response = await this.fetchWithRetry(async () => {
+      let headers = {
+        "Content-Type": "application/json",
+        "Authorization": await this.authorizationHeader()
+      };
+      this._requestLogger.debug("before POST %s", post_url);
+      return client.fetch(post_url, {
+        method: "POST",
+        body: JSON.stringify(body),
+        headers
+      });
+    });
+    if (response.status != 200) {
+      const message = await response.text();
+      return Promise.reject(`Unexpected status ${response.status}: ${message}`);
+    }
+    const result = await response.json();
+    this._requestLogger.debug("after POST %s", post_url);
+    return result["id"];
+  }
+  async manifest() {
+    this._logger.warn("getManifest for development use only");
     const client = this._client;
-    if (this._ingressEventWs || !this._baseUrl || !client) {
-      return;
+    const baseUrl = this._baseUrl;
+    if (!baseUrl || !client) {
+      return Promise.reject("endpoint not connected, use connect() before getManifest()");
     }
-    try {
+    let get_path;
+    if (this._sandboxId === null) {
+      get_path = `${baseUrl}/models/sources`;
+    } else {
+      get_path = `${baseUrl}/models/sources?sandboxId=${this._sandboxId}`;
+    }
+    let response = await this.fetchWithRetry(async () => {
       const session = await this.session();
-      let response = await this.fetchWithRetry(async () => {
-        const headers = {
-          "Authorization": `Bearer ${session.accessToken}`
-        };
-        const getTokenUrl = `${session.baseUrl}/liveIngress/events/token`;
-        return client.fetch(getTokenUrl, { headers });
-      });
-      if (response.status != 200) {
-        const message = await response.text();
-        return Promise.reject(`Unexpected status ${response.status}: ${message}`);
-      }
-      const wsAuthToken = await response.json();
-      const wsUrl = this._baseUrl.startsWith("https://") ? `${this._baseUrl.replace("https://", "wss://")}/liveIngress/events/${wsAuthToken.token}` : `${this._baseUrl.replace("http://", "ws://")}/liveIngress/events/${wsAuthToken.token}`;
-      this._ingressEventWs = new WebSocket(wsUrl);
-      this._ingressEventWs.addEventListener("message", (event) => {
-        const ingressEvent = JSON.parse(event.data);
-        if (this._ingressEventHandler) {
-          this._ingressEventHandler(ingressEvent);
-        }
-      });
-    } finally {
-      this.updateState();
+      let headers = {
+        "Authorization": `Bearer ${session.accessToken}`,
+        "Content-Type": "application/json"
+      };
+      this._requestLogger.debug("before GET %s", get_path);
+      return client.fetch(get_path, { headers });
+    });
+    if (!response.ok) {
+      const message = await response.text();
+      return Promise.reject(`Unexpected status ${response.status}: ${message}`);
     }
+    const result = await response.json();
+    this._requestLogger.debug("after GET %s", get_path);
+    return result;
   }
-  async uploadFile(source, params) {
-    if (!this._baseUrl || !this._pipelineId || !this._client || !this._limit) {
-      return Promise.reject("endpoint not connected, use connect() before upload()");
-    }
-    await this._limit.acquire();
-    try {
-      this.updateState();
-      const job = new UploadJob(source.file, source.file.type, params, async () => {
-        return this.session();
-      }, this._client, this._requestLogger);
-      return job.start(() => {
-        this.jobDone(job);
-      }, (statusCode) => {
-        this.jobStatus(job, statusCode);
-      });
-    } catch (e) {
-      this._limit.release();
-      throw e;
+  async models() {
+    this._logger.warn("listModels for development use only");
+    const client = this._client;
+    const baseUrl = this._baseUrl;
+    if (!baseUrl || !client) {
+      return Promise.reject("endpoint not connected, use connect() before listModels()");
     }
-  }
-  async uploadStream(source, params) {
-    if (!this._baseUrl || !this._pipelineId || !this._client || !this._limit) {
-      return Promise.reject("endpoint not connected, use connect() before upload()");
+    let get_path;
+    if (this._sandboxId === null) {
+      get_path = `${baseUrl}/models/instances`;
+    } else {
+      get_path = `${baseUrl}/models/instances?sandboxId=${this._sandboxId}`;
     }
-    await this._limit.acquire();
-    try {
-      this.updateState();
-      const job = new UploadJob(source.stream, source.mimeType, params, async () => {
-        return this.session();
-      }, this._client, this._requestLogger);
-      return job.start(() => {
-        this.jobDone(job);
-      }, (statusCode) => {
-        this.jobStatus(job, statusCode);
-      });
-    } catch (e) {
-      this._limit.release();
-      throw e;
+    let response = await this.fetchWithRetry(async () => {
+      const session = await this.session();
+      let headers = {
+        "Authorization": `Bearer ${session.accessToken}`,
+        "Content-Type": "application/json"
+      };
+      this._requestLogger.debug("before GET %s", get_path);
+      return client.fetch(get_path, { headers });
+    });
+    if (!response.ok) {
+      const message = await response.text();
+      return Promise.reject(`Unexpected status ${response.status}: ${message}`);
     }
+    const result = await response.json();
+    this._requestLogger.debug("after GET %s", get_path);
+    return result;
   }
-  async uploadPath(source, params) {
-    if (!this._baseUrl || !this._pipelineId || !this._client || !this._limit) {
-      throw new Error("endpoint not connected, use connect() before process()");
+  async changeManifest(manifests) {
+    this._logger.warn("setManifest for development use only");
+    const client = this._client;
+    const baseUrl = this._baseUrl;
+    if (!baseUrl || !client) {
+      return Promise.reject("endpoint not connected, use connect() before setManifest()");
     }
-    await this._limit.acquire();
-    try {
-      this.updateState();
-      const streamSource = await resolvePath(source);
-      const job = new UploadJob(streamSource.stream, streamSource.mimeType, params, async () => {
-        return this.session();
-      }, this._client, this._requestLogger);
-      return job.start(() => {
-        this.jobDone(job);
-      }, (statusCode) => {
-        this.jobStatus(job, statusCode);
+    let put_url;
+    if (this._sandboxId === null) {
+      put_url = `${baseUrl}/models/sources`;
+    } else {
+      put_url = `${baseUrl}/models/sources?sandboxId=${this._sandboxId}`;
+    }
+    let response = await this.fetchWithRetry(async () => {
+      const session = await this.session();
+      let headers = {
+        "Authorization": `Bearer ${session.accessToken}`,
+        "Content-Type": "application/json"
+      };
+      this._requestLogger.debug("before PUT %s", put_url);
+      return client.fetch(put_url, {
+        method: "PUT",
+        body: JSON.stringify(manifests),
+        headers
       });
-    } catch (e) {
-      this._limit.release();
-      throw e;
+    });
+    if (!response.ok) {
+      const message = await response.text();
+      return Promise.reject(`Unexpected status ${response.status}: ${message}`);
     }
+    this._requestLogger.debug("after PUT %s", put_url);
   }
-  async loadFrom(source, params) {
-    if (!this._baseUrl || !this._pipelineId || !this._client || !this._limit) {
-      throw new Error("endpoint not connected, use connect() before loadFrom()");
+  async loadModel(model) {
+    this._logger.warn("loadModel for development use only");
+    const client = this._client;
+    const baseUrl = this._baseUrl;
+    if (!baseUrl || !client) {
+      return Promise.reject("endpoint not connected, use connect() before loadModel()");
     }
-    await this._limit.acquire();
-    try {
-      this.updateState();
-      const job = new LoadFromJob(source.url, params, async () => {
-        return this.session();
-      }, this._client, this._requestLogger);
-      return job.start(() => {
-        this.jobDone(job);
-      }, (statusCode) => {
-        this.jobStatus(job, statusCode);
+    let post_url;
+    if (this._sandboxId === null) {
+      post_url = `${baseUrl}/models/instances`;
+    } else {
+      post_url = `${baseUrl}/models/instances?sandboxId=${this._sandboxId}`;
+    }
+    let response = await this.fetchWithRetry(async () => {
+      const session = await this.session();
+      let headers = {
+        "Authorization": `Bearer ${session.accessToken}`,
+        "Content-Type": "application/json"
+      };
+      this._requestLogger.debug("before POST %s", post_url);
+      return client.fetch(post_url, {
+        method: "POST",
+        body: JSON.stringify(model),
+        headers
       });
-    } catch (e) {
-      this._limit.release();
-      throw e;
+    });
+    if (!response.ok) {
+      const message = await response.text();
+      return Promise.reject(`Unexpected status ${response.status}: ${message}`);
     }
+    const result = await response.json();
+    this._requestLogger.debug("after POST %s", post_url);
+    return result;
   }
-  async loadLiveIngress(source, params) {
-    if (!this._baseUrl || !this._pipelineId || !this._client || !this._limit) {
-      throw new Error("endpoint not connected, use connect() before loadLiveIngress()");
+  async unloadModel(modelId) {
+    this._logger.warn("purgeModel for development use only");
+    const client = this._client;
+    const baseUrl = this._baseUrl;
+    if (!baseUrl || !client) {
+      return Promise.reject("endpoint not connected, use connect() before unloadModel()");
     }
-    await this._limit.acquire();
-    try {
-      this.updateState();
-      const job = new LoadLiveIngressJob(source.ingressId, params, async () => {
-        return this.session();
-      }, this._client, this._requestLogger);
-      return job.start(() => {
-        this.jobDone(job);
-      }, (statusCode) => {
-        this.jobStatus(job, statusCode);
-      });
-    } catch (e) {
-      this._limit.release();
-      throw e;
+    let delete_url;
+    if (this._sandboxId === null) {
+      delete_url = `${baseUrl}/models/instances/${modelId}`;
+    } else {
+      delete_url = `${baseUrl}/models/instances/${modelId}?sandboxId=${this._sandboxId}`;
+    }
+    let response = await this.fetchWithRetry(async () => {
+      const session = await this.session();
+      let headers = {
+        "Authorization": `Bearer ${session.accessToken}`,
+        "Content-Type": "application/json"
+      };
+      this._requestLogger.debug("before DELETE %s", delete_url);
+      return client.fetch(delete_url, { method: "DELETE", headers });
+    });
+    if (!response.ok) {
+      const message = await response.text();
+      return Promise.reject(`Unexpected status ${response.status}: ${message}`);
     }
+    this._requestLogger.debug("after DELETE %s", delete_url);
   }
-  jobDone(job) {
-    this._limit?.release();
-    this.updateState();
+};
+
+// shims/websockets.ts
+var createWebSocket;
+if ("document" in globalThis && "implementation" in globalThis.document) {
+  createWebSocket = (url, protocols) => {
+    return new WebSocket(url, protocols);
+  };
+} else {
+  createWebSocket = (url, protocols) => {
+    const ws = __require("ws");
+    return new ws.WebSocket(url, protocols);
+  };
+}
+
+// ../../node_modules/url-join/lib/url-join.js
+function normalize(strArray) {
+  var resultArray = [];
+  if (strArray.length === 0) {
+    return "";
   }
-  updateState(newState = void 0) {
-    const fromState = this._state;
-    if (newState == void 0) {
-      if (this._limit.getPermits() == this._options.jobQueueLength) {
-        newState = "Idle" /* Idle */;
-      } else {
-        newState = "Busy" /* Busy */;
-      }
+  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);
     }
-    this._state = newState;
-    if (this._stateChangeHandler) {
-      this._stateChangeHandler(fromState, this._state);
+    if (component === "") {
+      continue;
     }
-  }
-  jobStatus(job, statusCode) {
-    if (statusCode == 404) {
-      this._pipelineId = null;
-      this._baseUrl = null;
-    } else if (statusCode == 401) {
-      this._token = null;
-      this._expire_token_time = null;
+    if (i > 0) {
+      component = component.replace(/^[\/]+/, "");
+    }
+    if (i < strArray.length - 1) {
+      component = component.replace(/[\/]+$/, "");
+    } else {
+      component = component.replace(/[\/]+$/, "/");
     }
+    resultArray.push(component);
   }
-  async fetchWithRetry(fetcher, retries = 1) {
-    while (true) {
-      try {
-        const response = await fetcher();
-        if (response.status == 401) {
-          this._token = null;
-          this._expire_token_time = null;
-          if (retries--) {
-            this._requestLogger.info("received 401 response, attempt to reauthorize and retry");
-          } else {
-            return Promise.reject(`response ${response.status}: ${response.statusText}`);
-          }
-        } else if (response.status == 404) {
-          this._pipelineId = null;
-          this._baseUrl = null;
-          if (retries--) {
-            this._requestLogger.info("received 404 response, attempt to restart pop and retry");
-          } else {
-            return Promise.reject(`response ${response.status}: ${response.statusText}`);
-          }
-        } else {
-          return response;
-        }
-      } catch (error) {
-        this._pipelineId = null;
-        this._baseUrl = null;
-        if (retries--) {
-          this._requestLogger.info("unknown, attempt to restart pop (as if we received 404)", error);
-          return Promise.reject(error);
-        }
+  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_types.ts
+var AssetStatus = /* @__PURE__ */ ((AssetStatus2) => {
+  AssetStatus2["rejected"] = "rejected";
+  AssetStatus2["upload_in_progress"] = "upload_in_progress";
+  AssetStatus2["upload_failed"] = "upload_failed";
+  AssetStatus2["transform_failed"] = "transform_failed";
+  AssetStatus2["transform_in_progress"] = "transform_in_progress";
+  AssetStatus2["accepted"] = "accepted";
+  return AssetStatus2;
+})(AssetStatus || {});
+var AnnotationType = /* @__PURE__ */ ((AnnotationType2) => {
+  AnnotationType2["manual"] = "manual";
+  AnnotationType2["prediction"] = "prediction";
+  AnnotationType2["auto"] = "auto";
+  return AnnotationType2;
+})(AnnotationType || {});
+var UserReview = /* @__PURE__ */ ((UserReview3) => {
+  UserReview3["approved"] = "approved";
+  UserReview3["rejected"] = "rejected";
+  UserReview3["unknown"] = "unknown";
+  return UserReview3;
+})(UserReview || {});
+var TranscodeMode = /* @__PURE__ */ ((TranscodeMode2) => {
+  TranscodeMode2["original"] = "original";
+  TranscodeMode2["image_original_size"] = "image_original_size";
+  TranscodeMode2["image_fit_1024"] = "image_fit_1024";
+  TranscodeMode2["image_fit_640"] = "image_fit_640";
+  TranscodeMode2["image_fit_224"] = "image_fit_224";
+  TranscodeMode2["image_cover_1024"] = "image_cover_1024";
+  TranscodeMode2["image_cover_640"] = "image_cover_640";
+  TranscodeMode2["image_cover_224"] = "image_cover_224";
+  return TranscodeMode2;
+})(TranscodeMode || {});
+var ModelType = /* @__PURE__ */ ((ModelType2) => {
+  ModelType2["epdet_b1"] = "epdet_b1";
+  return ModelType2;
+})(ModelType || {});
+var ModelStatus = /* @__PURE__ */ ((ModelStatus2) => {
+  ModelStatus2["error"] = "error";
+  ModelStatus2["draft"] = "draft";
+  ModelStatus2["requested"] = "requested";
+  ModelStatus2["in_progress"] = "in_progress";
+  ModelStatus2["available"] = "available";
+  ModelStatus2["published"] = "published";
+  return ModelStatus2;
+})(ModelStatus || {});
+var ChangeType = /* @__PURE__ */ ((ChangeType2) => {
+  ChangeType2["dataset_added"] = "dataset_added";
+  ChangeType2["dataset_removed"] = "dataset_removed";
+  ChangeType2["dataset_modified"] = "dataset_modified";
+  ChangeType2["dataset_version_modified"] = "dataset_version_modified";
+  ChangeType2["asset_added"] = "asset_added";
+  ChangeType2["asset_removed"] = "asset_removed";
+  ChangeType2["asset_status_modified"] = "asset_status_modified";
+  ChangeType2["asset_annotation_modified"] = "asset_annotation_modified";
+  ChangeType2["model_added"] = "model_added";
+  ChangeType2["model_removed"] = "model_removed";
+  ChangeType2["model_modified"] = "model_modified";
+  ChangeType2["model_status_modified"] = "model_status_modified";
+  return ChangeType2;
+})(ChangeType || {});
+
+// data/data_endpoint.ts
+var WS_INITIAL_RECONNECT_DELAY = 1e3;
+var WS_MAX_RECONNECT_DELAY = 6e4;
+var DataEndpoint = class extends Endpoint {
+  constructor(options) {
+    super(options);
+    this._baseUrl = null;
+    this._ws = null;
+    this._ws_current_reconnect_delay = null;
+    this._accountId = options.accountId || null;
+    this._account_event_handlers = [];
+    this._dataset_uuid_to_event_handlers = /* @__PURE__ */ new Map();
+    const sessionAuth = options.auth;
+    if (sessionAuth.session !== void 0) {
+      const dataSession = sessionAuth.session;
+      if (dataSession.accountId) {
+        this._accountId = dataSession.accountId;
+      }
+    }
+  }
+  async session() {
+    const session = await super.session();
+    return {
+      eyepopUrl: session.eyepopUrl,
+      accessToken: session.accessToken,
+      validUntil: session.validUntil,
+      accountId: this.options().accountId,
+      baseUrl: this._baseUrl
+    };
+  }
+  async disconnect(wait = true) {
+    this._baseUrl = null;
+    if (this._ws) {
+      try {
+        this._ws.close();
+      } catch (e) {
+        this._logger.warn("ignored exception", e);
       }
+      this._ws = null;
     }
+    await super.disconnect(wait);
   }
   async reconnect() {
     if (!this._client) {
       return Promise.reject("endpoint not initialized");
     }
-    let config_url;
-    if (this._options.popId == "transient" /* Transient */) {
-      config_url = `${this.eyepopUrl()}/workers/config`;
-    } else {
-      config_url = `${this.eyepopUrl()}/pops/${this._options.popId}/config?auto_start=false`;
-    }
-    const headers = {
+    const config_url = `${this.eyepopUrl()}/data/config?account_uuid=${this._accountId}`;
+    let headers = {
       "Authorization": await this.authorizationHeader()
     };
     this.updateState("FetchConfig" /* FetchConfig */);
@@ -10234,193 +10838,368 @@ var Endpoint = class {
     let response = await this._client.fetch(config_url, { headers });
     if (response.status == 401) {
       this._requestLogger.debug("after GET %s: 401, about to retry with fresh access token", config_url);
-      this._token = null;
-      const headers2 = {
+      this.statusHandler401(response.status);
+      headers = {
         "Authorization": await this.authorizationHeader()
       };
       this.updateState("FetchConfig" /* FetchConfig */);
       response = await this._client.fetch(config_url, {
-        headers: headers2
+        headers
       });
     }
     if (response.status != 200) {
       this.updateState("Error" /* Error */);
       const message = await response.text();
       return Promise.reject(`Unexpected status ${response.status}: ${message}`);
+    }
+    let config = await response.json();
+    this._requestLogger.debug("after GET %s", config_url);
+    const baseUrl = new URL(config.base_url, this.eyepopUrl());
+    this._baseUrl = baseUrl.toString();
+    if (this.options().disableWs) {
+      this._logger.info("disabled ws connection");
     } else {
-      let config = await response.json();
-      if (!config.base_url && this._options.autoStart) {
-        const auto_start_config_url = `${this.eyepopUrl()}/pops/${this._options.popId}/config?auto_start=true`;
-        this._requestLogger.debug("pop was not running, trying to autostart with: %s", auto_start_config_url);
-        const headers2 = {
-          "Authorization": await this.authorizationHeader()
-        };
-        this.updateState("StartingPop" /* StartingPop */);
-        response = await this._client.fetch(auto_start_config_url, {
-          headers: headers2
-        });
-        if (response.status != 200) {
-          this.updateState("Error" /* Error */);
-          const message = await response.text();
-          return Promise.reject(`Unexpected status ${response.status}: ${message}`);
-        }
-        config = await response.json();
-      }
-      const baseUrl = new URL(config.base_url, this.eyepopUrl());
-      this._baseUrl = baseUrl.toString();
-      if (this._options.popId == "transient" /* Transient */) {
-        this._pipelineId = await this.startPopLessPipeline();
-        this._popName = this._options.popId;
-      } else {
-        this._pipelineId = config.pipeline_id;
-        this._popName = config.name;
-      }
-      this._requestLogger.debug("after GET %s: %s / %s", config_url, this._baseUrl, this._pipelineId);
-      if (!this._pipelineId || !this._baseUrl) {
-        return Promise.reject(`Pop not started`);
+      await this.reconnect_ws();
+    }
+    this.updateState();
+    return Promise.resolve(this);
+  }
+  async reconnect_ws() {
+    if (this._ws) {
+      this._ws.close();
+      this._ws = null;
+    }
+    const baseUrl = this._baseUrl?.replace("https://", "wss://").replace("http://", "ws://");
+    if (!baseUrl) {
+      return;
+    }
+    const ws_url = urlJoin(baseUrl, "events");
+    this._requestLogger.debug("about to connect ws to: %s", ws_url);
+    return new Promise((resolve, reject) => {
+      const ws = createWebSocket(ws_url);
+      if (!ws) {
+        return resolve();
       }
-      this._baseUrl = this._baseUrl.replace(/\/+$/, "");
-      if (this._baseUrl) {
-        const get_url = `${this._baseUrl}/pipelines/${this._pipelineId}`;
-        const headers2 = {
-          "Authorization": await this.authorizationHeader()
-        };
-        this._requestLogger.debug("before GET %s", get_url);
-        let response2 = await this._client.fetch(get_url, {
-          method: "GET",
-          headers: headers2
-        });
-        if (response2.status > 200) {
-          const message = await response2.text();
-          return Promise.reject(`Unexpected status ${response2.status}: ${message}`);
+      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.onmessage = (event) => {
+        const data = JSON.parse(event.data);
+        this._requestLogger.debug("received ws: %s", JSON.stringify(data));
+        const change_event = data;
+        this.dispatchChangeEvent(change_event);
+      };
+      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);
         }
-        this._requestLogger.debug("after GET %s", get_url);
-        this._pipeline = await response2.json();
+      };
+      ws.onerror = (event) => {
+        this._logger.error(event);
+        reject(event);
+        return null;
+      };
+    });
+  }
+  options() {
+    return this._options;
+  }
+  async request(path2, options = {}, disableAuth = false) {
+    const client = this._client;
+    const baseUrl = this._baseUrl;
+    if (!baseUrl || !client) {
+      return Promise.reject("endpoint not connected, use connect() before changePopComp()");
+    }
+    let response = await this.fetchWithRetry(async () => {
+      const session = await this.session();
+      const headers = {
+        "Content-Type": "application/json",
+        ...disableAuth ? {} : { "Authorization": `Bearer ${session.accessToken}` },
+        ...options.headers || {}
+      };
+      if (!options.body) {
+        options.body = null;
       }
-      this.updateState();
-      return Promise.resolve(this);
+      const ri = {
+        headers,
+        method: options.method || "GET",
+        body: options.body
+      };
+      this._requestLogger.debug("Request - " + ri.method + path2 + " BODY: " + (ri.body ? ri.body : ""));
+      return await client.fetch(urlJoin(session.baseUrl ?? "", path2), ri);
+    });
+    if (response.status === 204) {
+      return null;
+    }
+    if (!response.ok) {
+      const errorData = await response.json();
+      throw new Error(errorData.detail || "Request failed");
+    }
+    const contentType = response.headers.get("Content-Type");
+    if (contentType && contentType.startsWith("image/")) {
+      const blob = await response.blob();
+      return blob;
     }
+    this._requestLogger.debug("Response - " + response.status + " " + response.statusText);
+    return response.json();
   }
-  async authorizationHeader() {
-    return `Bearer ${await this.currentAccessToken()}`;
+  async listDatasets() {
+    return this.request(`/datasets?account_uuid=${this._accountId}`, {
+      method: "GET"
+    });
   }
-  async currentAccessToken() {
-    const now = Date.now() / 1e3;
-    if (!this._token || this._expire_token_time < now) {
-      this.updateState("Authenticating" /* Authenticating */);
-      try {
-        if (!this._client) {
-          return Promise.reject("endpoint not connected");
-        } else if (this._options.auth.session !== void 0) {
-          return Promise.reject("temporary access token expired");
-        } else if (this._options.auth.oAuth2 !== void 0 && this._options.eyepopUrl && this._options.popId) {
-          const session = await authenticateBrowserSession(
-            this._options.auth.oAuth2,
-            this._options.eyepopUrl,
-            this._options.popId
-          );
-          this._token = session.accessToken;
-          this._expire_token_time = session.validUntil / 1e3;
-        } else if (this._options.auth.secretKey !== void 0 && this._options.eyepopUrl) {
-          const secretKeyAuth = this._options.auth;
-          const body = { "secret_key": secretKeyAuth.secretKey };
-          const headers = { "Content-Type": "application/json" };
-          const post_url = `${this.eyepopUrl()}/authentication/token`;
-          this._requestLogger.debug("before POST %s", post_url);
-          const response = await this._client.fetch(post_url, {
-            method: "POST",
-            headers,
-            body: JSON.stringify(body)
-          });
-          if (response.status != 200) {
-            const message = await response.text();
-            return Promise.reject(`Unexpected status ${response.status}: ${message}`);
-          }
-          this._requestLogger.debug("after POST %s", post_url);
-          const data = await response.json();
-          const token = data;
-          this._token = token.access_token;
-          this._expire_token_time = now + token.expires_in - 60;
-        } else {
-          return Promise.reject("no valid auth option");
-        }
-      } finally {
-        this.updateState();
+  async createDataset(data) {
+    return this.request(`/datasets?account_uuid=${this._accountId}`, {
+      method: "POST",
+      body: JSON.stringify(data)
+    });
+  }
+  async getDataset(dataset_uuid) {
+    return this.request(`/datasets/${dataset_uuid}`, {
+      method: "GET"
+    });
+  }
+  async updateDataset(dataset_uuid, data) {
+    return this.request(`/datasets/${dataset_uuid}`, {
+      method: "PATCH",
+      body: JSON.stringify(data)
+    });
+  }
+  async deleteDataset(dataset_uuid) {
+    return this.request(`/datasets/${dataset_uuid}`, {
+      method: "DELETE"
+    });
+  }
+  async freezeDatasetVersion(dataset_uuid, dataset_version) {
+    const versionQuery = dataset_version ? `&dataset_version=${dataset_version}` : "";
+    return this.request(`/datasets/${dataset_uuid}/freeze?${versionQuery}`, {
+      method: "POST"
+    });
+  }
+  async deleteDatasetVersion(dataset_uuid, dataset_version) {
+    return this.request(`/datasets/${dataset_uuid}/delete?dataset_version=${dataset_version}`, {
+      method: "POST"
+    });
+  }
+  // Asset methods
+  async uploadAsset(dataset_uuid, dataset_version, blob) {
+    return this.request(`/assets?dataset_uuid=${dataset_uuid}&dataset_version=${dataset_version}`, {
+      method: "POST",
+      body: blob,
+      headers: {
+        "Content-Type": blob.type || "application/octet-stream"
       }
+    });
+  }
+  async listAssets(dataset_uuid, dataset_version, include_annotations = false) {
+    const versionQuery = dataset_version ? `&dataset_version=${dataset_version}` : "";
+    const annotationsQuery = include_annotations ? "&include_annotations=true" : "";
+    return this.request(`/assets?dataset_uuid=${dataset_uuid}${versionQuery}${annotationsQuery}`, {
+      method: "GET"
+    });
+  }
+  async getAsset(asset_uuid, dataset_uuid, dataset_version, include_annotations = false) {
+    const versionQuery = dataset_version ? `&dataset_version=${dataset_version}` : "";
+    const annotationsQuery = include_annotations ? "&include_annotations=true" : "";
+    const datasetQuery = dataset_uuid ? `&dataset_uuid=${dataset_uuid}` : "";
+    return this.request(`/assets/${asset_uuid}?${datasetQuery}${versionQuery}${annotationsQuery}`, {
+      method: "GET"
+    });
+  }
+  async deleteAsset(asset_uuid, dataset_uuid, dataset_version) {
+    const versionQuery = dataset_version ? `&dataset_version=${dataset_version}` : "";
+    const datasetQuery = dataset_uuid ? `&dataset_uuid=${dataset_uuid}` : "";
+    return this.request(`/assets/${asset_uuid}?${datasetQuery}${versionQuery}`, {
+      method: "DELETE"
+    });
+  }
+  async resurrectAsset(asset_uuid, dataset_uuid, from_dataset_version, into_dataset_version) {
+    const intoVersionQuery = into_dataset_version ? `&into_dataset_version=${into_dataset_version}` : "";
+    return this.request(`/assets/${asset_uuid}/resurrect?dataset_uuid=${dataset_uuid}&from_dataset_version=${from_dataset_version}${intoVersionQuery}`, {
+      method: "POST"
+    });
+  }
+  async updateAssetManualAnnotation(asset_uuid, dataset_uuid, dataset_version, prediction) {
+    const versionQuery = dataset_version ? `&dataset_version=${dataset_version}` : "";
+    const datasetQuery = dataset_uuid ? `&dataset_uuid=${dataset_uuid}` : "";
+    return this.request(`/assets/${asset_uuid}/manual_annotate?${datasetQuery}${versionQuery}`, {
+      method: "PATCH",
+      body: JSON.stringify(prediction)
+    });
+  }
+  async updateAutoAnnotationStatus(asset_uuid, auto_annotate, user_review) {
+    const validStatuses = ["approved", "rejected", "unknown"];
+    if (!validStatuses.includes(user_review)) {
+      throw new Error("Invalid status");
     }
-    this._logger.debug("using access token, valid for at least %d seconds", this._expire_token_time - now);
-    return this._token;
+    return this.request(`/assets/${asset_uuid}/auto_annotations/${auto_annotate}/user_review/${user_review}`, {
+      method: "PATCH"
+    });
   }
-  async startPopLessPipeline() {
-    if (this._client == null || this._baseUrl == null) {
-      return Promise.reject("endpoint not initialized");
+  async downloadAsset(asset_uuid, dataset_uuid, dataset_version, transcode_mode = "original" /* original */) {
+    const versionQuery = dataset_version ? `&dataset_version=${dataset_version}` : "";
+    const datasetQuery = dataset_uuid ? `&dataset_uuid=${dataset_uuid}` : "";
+    return this.request(`/assets/${asset_uuid}/download?${datasetQuery}${versionQuery}&transcode_mode=${transcode_mode}`, {
+      method: "GET"
+    });
+  }
+  // Model methods
+  async listModels() {
+    return this.request(`/models?account_uuid=${this._accountId}`, {
+      method: "GET"
+    });
+  }
+  async createModel(dataset_uuid, dataset_version, data) {
+    return this.request(`/models?dataset_uuid=${dataset_uuid}&dataset_version=${dataset_version}`, {
+      method: "POST",
+      body: JSON.stringify(data)
+    });
+  }
+  async getModel(model_uuid) {
+    return this.request(`/models/${model_uuid}`, {
+      method: "GET"
+    });
+  }
+  async updateModel(model_uuid, data) {
+    return this.request(`/models/${model_uuid}`, {
+      method: "PATCH",
+      body: JSON.stringify(data)
+    });
+  }
+  async deleteModel(model_uuid) {
+    return this.request(`/models/${model_uuid}`, {
+      method: "DELETE"
+    });
+  }
+  async publishModel(model_uuid) {
+    return this.request(`/models/${model_uuid}/publish`, {
+      method: "POST"
+    });
+  }
+  addAccountEventHandler(eventHandler) {
+    this._account_event_handlers.push(eventHandler);
+  }
+  removeAccountEventHandler(eventHandler) {
+    this._account_event_handlers = this._account_event_handlers.filter((h) => h !== eventHandler);
+  }
+  addDatasetEventHandler(dataset_uuid, eventHandler) {
+    let event_handlers = this._dataset_uuid_to_event_handlers.get(dataset_uuid);
+    this._logger.debug("addDatasetEventHandler %s", event_handlers);
+    if (event_handlers === void 0) {
+      event_handlers = [];
+      this._dataset_uuid_to_event_handlers.set(dataset_uuid, event_handlers);
+      const ws = this._ws;
+      if (ws) {
+        const msg = JSON.stringify({ subscribe: { dataset_uuid } });
+        this._requestLogger.debug("ws send: %s", msg);
+        ws.send(msg);
+      }
     }
-    this.updateState("StartingPop" /* StartingPop */);
-    let pipeline;
-    if (this._pipeline) {
-      pipeline = this._pipeline.inferPipeline;
-    } else {
-      pipeline = "identity";
+    if (event_handlers.find((h) => h === eventHandler) !== eventHandler) {
+      this._logger.debug("addDatasetEventHandler event_handlers=%s", event_handlers);
+      event_handlers.push(eventHandler);
     }
-    let postTransform;
-    if (this._pipeline && this._pipeline.postTransform) {
-      postTransform = this._pipeline.postTransform;
-    } else {
-      postTransform = null;
+  }
+  removeDatasetEventHandler(dataset_uuid, eventHandler) {
+    let event_handlers = this._dataset_uuid_to_event_handlers.get(dataset_uuid);
+    if (event_handlers === void 0) {
+      return;
     }
-    const body = {
-      "inferPipelineDef": {
-        "pipeline": pipeline
-      },
-      "postTransformDef": {
-        "transform": postTransform
-      },
-      "source": {
-        "sourceType": "NONE"
-      },
-      "idleTimeoutSeconds": 30,
-      "logging": ["out_meta"],
-      "videoOutput": "no_output"
-    };
-    let post_url;
-    if (this._sandboxId) {
-      post_url = `${this._baseUrl.replace(/\/+$/, "")}/pipelines?sandboxId=${this._sandboxId}`;
-    } else {
-      post_url = `${this._baseUrl.replace(/\/+$/, "")}/pipelines`;
+    event_handlers = event_handlers.filter((h) => h !== eventHandler);
+    if (event_handlers.length == 0) {
+      const ws = this._ws;
+      if (ws) {
+        const msg = JSON.stringify({ unsubscribe: { dataset_uuid } });
+        this._requestLogger.debug("ws send: %s", msg);
+        ws.send(msg);
+      }
+      this._dataset_uuid_to_event_handlers.delete(dataset_uuid);
     }
-    let headers = {
-      "Content-Type": "application/json",
-      "Authorization": await this.authorizationHeader()
-    };
-    this._requestLogger.debug("before POST %s", post_url);
-    let response = await this._client.fetch(post_url, {
-      method: "POST",
-      headers,
-      body: JSON.stringify(body)
-    });
-    if (response.status == 401) {
-      this._requestLogger.debug("after GET %s: 401, about to retry with fresh access token", post_url);
-      this._token = null;
-      headers = {
-        "Content-Type": "application/json",
-        "Authorization": await this.authorizationHeader()
-      };
-      response = await this._client.fetch(post_url, {
-        method: "POST",
-        headers,
-        body: JSON.stringify(body)
-      });
+  }
+  removeAllDatasetEventHandlers(dataset_uuid) {
+    let event_handlers = this._dataset_uuid_to_event_handlers.get(dataset_uuid);
+    if (event_handlers === void 0) {
+      return;
     }
-    if (response.status != 200) {
-      const message = await response.text();
-      return Promise.reject(`Unexpected status ${response.status}: ${message}`);
+    const ws = this._ws;
+    if (ws) {
+      const msg = JSON.stringify({ unsubscribe: { dataset_uuid } });
+      this._requestLogger.debug("ws send: %s", msg);
+      ws.send(msg);
+    }
+    this._dataset_uuid_to_event_handlers.delete(dataset_uuid);
+  }
+  async dispatchChangeEvent(change_event) {
+    switch (change_event.change_type) {
+      case "dataset_added" /* dataset_added */:
+      case "dataset_modified" /* dataset_modified */:
+      case "dataset_removed" /* dataset_removed */:
+      case "dataset_version_modified" /* dataset_version_modified */:
+        for (let handler of this._account_event_handlers) {
+          await handler(change_event);
+        }
+      case "asset_added" /* asset_added */:
+      case "asset_removed" /* asset_removed */:
+      case "asset_status_modified" /* asset_status_modified */:
+      case "asset_annotation_modified" /* asset_annotation_modified */:
+      case "model_added" /* model_added */:
+      case "model_modified" /* model_modified */:
+      case "model_removed" /* model_removed */:
+      case "model_status_modified" /* model_status_modified */:
+        const event_handlers = this._dataset_uuid_to_event_handlers.get(change_event.dataset_uuid);
+        this._logger.debug("dispatchChangeEvent event_handlers=%s", event_handlers);
+        if (event_handlers !== void 0) {
+          for (let handler of event_handlers) {
+            await handler(change_event);
+          }
+        }
+        break;
     }
-    this._requestLogger.debug("after POST %s", post_url);
-    const pipelineId = (await response.json())["id"];
-    return pipelineId;
   }
 };
 
+// worker/worker_types.ts
+var ModelFormat = /* @__PURE__ */ ((ModelFormat2) => {
+  ModelFormat2["TensorFlowLite"] = "TensorFlowLite";
+  ModelFormat2["TensorFlowGraphDef"] = "TensorFlowGraphDef";
+  ModelFormat2["ONNX"] = "ONNX";
+  ModelFormat2["TorchScript"] = "TorchScript";
+  ModelFormat2["TorchScriptCpu"] = "TorchScriptCpu";
+  ModelFormat2["TorchScriptCuda"] = "TorchScriptCuda";
+  return ModelFormat2;
+})(ModelFormat || {});
+var ModelPrecisionType = /* @__PURE__ */ ((ModelPrecisionType2) => {
+  ModelPrecisionType2["float32"] = "float32";
+  ModelPrecisionType2["float16"] = "float16";
+  ModelPrecisionType2["int32"] = "int32";
+  ModelPrecisionType2["int8"] = "int8";
+  ModelPrecisionType2["uint8"] = "uint8";
+  return ModelPrecisionType2;
+})(ModelPrecisionType || {});
+
 // index.ts
 var readEnv = (env) => {
   if (typeof process !== "undefined") {
@@ -10434,29 +11213,57 @@ var EyePop;
   const defaultAuth = envSecretKey ? {
     secretKey: envSecretKey
   } : void 0;
-  function endpoint(opts = {}) {
-    if (typeof opts.auth == "undefined") {
-      if (typeof defaultAuth == "undefined") {
-        throw new Error("auth option or EYEPOP_SECRET_KEY environment variable is required");
-      }
-      opts.auth = defaultAuth;
-    }
+  EyePop2.endpoint = workerEndpoint;
+  function workerEndpoint(opts = {}) {
+    _fill_default_options(opts);
     if (typeof opts.popId == "undefined") {
       opts.popId = readEnv("EYEPOP_POP_ID");
     }
-    if (typeof opts.eyepopUrl == "undefined") {
-      opts.eyepopUrl = readEnv("EYEPOP_URL") || "https://api.eyepop.ai";
-    }
     if (typeof opts.autoStart == "undefined") {
       opts.autoStart = true;
     }
     if (typeof opts.stopJobs == "undefined") {
       opts.stopJobs = true;
     }
+    if (opts.auth.session !== void 0) {
+      if (opts.auth.session !== void 0) {
+        if (opts.auth.session.popId) {
+          opts.popId = opts.auth.session.popId;
+        }
+      }
+    }
+    return new WorkerEndpoint(opts);
+  }
+  EyePop2.workerEndpoint = workerEndpoint;
+  function dataEndpoint(opts = {}) {
+    _fill_default_options(opts);
+    if (typeof opts.accountId == "undefined") {
+      opts.accountId = readEnv("EYEPOP_ACCOUNT_ID");
+    }
+    if (opts.auth.session !== void 0) {
+      if (opts.auth.session !== void 0) {
+        if (opts.auth.session.accountId) {
+          opts.accountId = opts.auth.session.accountId;
+        }
+      }
+    }
+    return new DataEndpoint(opts);
+  }
+  EyePop2.dataEndpoint = dataEndpoint;
+  function _fill_default_options(opts) {
+    if (typeof opts.auth == "undefined") {
+      if (typeof defaultAuth == "undefined") {
+        throw new Error("auth option or EYEPOP_SECRET_KEY environment variable is required");
+      }
+      opts.auth = defaultAuth;
+    }
+    if (typeof opts.eyepopUrl == "undefined") {
+      opts.eyepopUrl = readEnv("EYEPOP_URL") || "https://api.eyepop.ai";
+    }
     if (typeof opts.jobQueueLength == "undefined") {
       opts.jobQueueLength = 1024;
     }
-    if (typeof opts.auth.oAuth2 != "undefined" && opts.popId) {
+    if (typeof opts.auth.oAuth2 != "undefined") {
       if (typeof opts.auth.oAuth2 === "boolean") {
         if (opts.eyepopUrl.startsWith("https://staging-api.eyepop.ai")) {
           opts.auth = {
@@ -10480,22 +11287,28 @@ var EyePop;
       }
     }
     if (opts.auth.session !== void 0) {
-      if (opts.auth.session.popId) {
-        opts.popId = opts.auth.session.popId;
-      }
       if (opts.auth.session.eyepopUrl) {
         opts.eyepopUrl = opts.auth.session.eyepopUrl;
       }
     }
-    const endpoint2 = new Endpoint(opts);
-    return endpoint2;
   }
-  EyePop2.endpoint = endpoint;
 })(EyePop || (EyePop = {}));
 var eyepop_default = EyePop;
 export {
+  AnnotationType,
+  AssetStatus,
+  ChangeType,
+  DataEndpoint,
   EndpointState,
   EyePop,
+  ModelFormat,
+  ModelPrecisionType,
+  ModelStatus,
+  ModelType,
+  TranscodeMode,
+  TransientPopId,
+  UserReview,
+  WorkerEndpoint,
   eyepop_default as default
 };
 /*! Bundled license information: