@eyepop.ai/eyepop 0.9.1 → 0.10.0

package/dist/index.js

@@ -1,9 +1,7 @@
 "use strict";
-var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __commonJS = (cb, mod) => function __require() {
   return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
@@ -20,14 +18,6 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // node_modules/mime-db/db.json
@@ -8584,9 +8574,9 @@ var require_mime_types = __commonJS({
         return false;
       }
       var match = EXTRACT_TYPE_REGEXP.exec(type);
-      var mime2 = match && db[match[1].toLowerCase()];
-      if (mime2 && mime2.charset) {
-        return mime2.charset;
+      var mime = match && db[match[1].toLowerCase()];
+      if (mime && mime.charset) {
+        return mime.charset;
       }
       if (match && TEXT_TYPE_REGEXP.test(match[1])) {
         return "UTF-8";
@@ -8597,16 +8587,16 @@ var require_mime_types = __commonJS({
       if (!str || typeof str !== "string") {
         return false;
       }
-      var mime2 = str.indexOf("/") === -1 ? exports2.lookup(str) : str;
-      if (!mime2) {
+      var mime = str.indexOf("/") === -1 ? exports2.lookup(str) : str;
+      if (!mime) {
         return false;
       }
-      if (mime2.indexOf("charset") === -1) {
-        var charset2 = exports2.charset(mime2);
+      if (mime.indexOf("charset") === -1) {
+        var charset2 = exports2.charset(mime);
         if (charset2)
-          mime2 += "; charset=" + charset2.toLowerCase();
+          mime += "; charset=" + charset2.toLowerCase();
       }
-      return mime2;
+      return mime;
     }
     function extension(type) {
       if (!type || typeof type !== "string") {
@@ -8632,8 +8622,8 @@ var require_mime_types = __commonJS({
     function populateMaps(extensions, types) {
       var preference = ["nginx", "apache", void 0, "iana"];
       Object.keys(db).forEach(function forEachMimeType(type) {
-        var mime2 = db[type];
-        var exts = mime2.extensions;
+        var mime = db[type];
+        var exts = mime.extensions;
         if (!exts || !exts.length) {
           return;
         }
@@ -8642,7 +8632,7 @@ var require_mime_types = __commonJS({
           var extension2 = exts[i];
           if (types[extension2]) {
             var from = preference.indexOf(db[types[extension2]].source);
-            var to = preference.indexOf(mime2.source);
+            var to = preference.indexOf(mime.source);
             if (types[extension2] !== "application/octet-stream" && (from > to || from === to && types[extension2].substr(0, 12) === "application/")) {
               continue;
             }
@@ -8657,10 +8647,23 @@ var require_mime_types = __commonJS({
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
-  EyePopSdk: () => EyePopSdk
+  EndpointState: () => EndpointState,
+  EyePopSdk: () => EyePopSdk,
+  default: () => src_default
 });
 module.exports = __toCommonJS(src_exports);
 
+// src/types.ts
+var EndpointState = /* @__PURE__ */ ((EndpointState2) => {
+  EndpointState2["Idle"] = "Idle";
+  EndpointState2["Busy"] = "Busy";
+  EndpointState2["Authenticating"] = "Authenticating";
+  EndpointState2["FetchConfig"] = "FetchConfig";
+  EndpointState2["StartingPop"] = "StartingPop";
+  EndpointState2["Error"] = "Error";
+  return EndpointState2;
+})(EndpointState || {});
+
 // src/streaming.ts
 var Stream = class _Stream {
   constructor(iterator, controller) {
@@ -8913,16 +8916,13 @@ function readableStreamAsyncIterable(stream) {
 }
 
 // src/jobs.ts
-var _AbstractJob = class _AbstractJob {
-  constructor(baseUrl, pipelineId, authorizationHeader, dispatcher, requestLogger) {
+var AbstractJob = class {
+  constructor(getSession, client, requestLogger) {
     this._responseStream = null;
     this._controller = new AbortController();
-    this._baseUrl = baseUrl.replace(/\/+$/, "");
-    this._pipelineId = pipelineId;
-    this._authorizationHeader = authorizationHeader;
-    this._dispatcher = dispatcher;
+    this._getSession = getSession;
+    this._client = client;
     this._requestLogger = requestLogger;
-    this.i = _AbstractJob.n++;
   }
   [Symbol.asyncIterator]() {
     if (!this._responseStream) {
@@ -8930,25 +8930,58 @@ var _AbstractJob = class _AbstractJob {
     }
     return Stream.iterFromReadableStream(this._responseStream, this._controller);
   }
-  async _fetch() {
+  async startJob() {
     return Promise.reject("abstract class");
   }
-  start(done) {
-    this._responseStream = new Promise((resolve, reject) => {
-      const request = this._fetch();
-      request.then((response) => {
-        if (response.status != 200) {
-          reject(`upload error ${response.status}: ${response.text()}`);
-        } else if (!response.body) {
-          reject(`response body is empty`);
-        } else {
-          resolve(response.body);
+  start(done, status) {
+    this._responseStream = new Promise(async (resolve2, reject) => {
+      try {
+        let retries = 1;
+        while (true) {
+          try {
+            const response = await this.startJob();
+            if (response.status == 401) {
+              status(response.status);
+              if (retries--) {
+                this._requestLogger.info("received 401 response, attempt to reauthorize once");
+              } else {
+                reject(`response ${response.status}: ${response.statusText}`);
+                break;
+              }
+            } else if (response.status == 404) {
+              status(response.status);
+              if (retries--) {
+                this._requestLogger.info("received 404 response, attempt to restart pop");
+              } else {
+                reject(`response ${response.status}: ${response.statusText}`);
+                break;
+              }
+            } else if (response.status != 200) {
+              reject(`upload error ${response.status}: ${await response.text()}`);
+              break;
+            } else if (!response.body) {
+              reject(`response body is empty`);
+              break;
+            } else {
+              resolve2(response.body);
+              break;
+            }
+          } catch (error) {
+            if (retries--) {
+              this._requestLogger.info("unknown, attempt to restart pop (as if we received 404)", error);
+              status(404);
+            } else {
+              status(500);
+              reject(error);
+              break;
+            }
+          }
         }
-      }).catch((reason) => {
+      } catch (reason) {
         reject(reason);
-      }).finally(() => {
+      } finally {
         done();
-      });
+      }
     });
     return this;
   }
@@ -8956,26 +8989,26 @@ var _AbstractJob = class _AbstractJob {
     this._controller.abort("cancelled");
   }
 };
-_AbstractJob.n = 0;
-var AbstractJob = _AbstractJob;
+AbstractJob.n = 0;
 var UploadJob = class extends AbstractJob {
   get [Symbol.toStringTag]() {
     return "uploadJob";
   }
-  constructor(stream, mimeType, baseUrl, pipelineId, authorizationHeader, dispatcher, requestLogger) {
-    super(baseUrl, pipelineId, authorizationHeader, dispatcher, requestLogger);
+  constructor(stream, mimeType, getSession, client, requestLogger) {
+    super(getSession, client, requestLogger);
     this._uploadStream = stream;
     this._mimeType = mimeType;
   }
-  async _fetch() {
+  async startJob() {
+    const session = await this._getSession();
     const headers = {
-      "Authorization": this._authorizationHeader,
+      "Authorization": `Bearer ${session.accessToken}`,
       "Accept": "application/jsonl",
       "Content-Type": this._mimeType
     };
-    const postUrl = `${this._baseUrl}/pipelines/${this._pipelineId}/source?mode=queue&processing=sync`;
+    const postUrl = `${session.baseUrl.replace(/\/+$/, "")}/pipelines/${session.pipelineId}/source?mode=queue&processing=sync`;
     this._requestLogger.debug("before POST %s with stream as body");
-    const response = await fetch(postUrl, {
+    const response = await this._client.fetch(postUrl, {
       headers,
       method: "POST",
       body: this._uploadStream,
@@ -8989,26 +9022,27 @@ var UploadJob = class extends AbstractJob {
   }
 };
 var LoadFromJob = class extends AbstractJob {
-  constructor(location, baseUrl, pipelineId, authorizationHeader, dispatcher, requestLogger) {
-    super(baseUrl, pipelineId, authorizationHeader, dispatcher, requestLogger);
+  constructor(location, getSession, client, requestLogger) {
+    super(getSession, client, requestLogger);
     this._location = location;
   }
   get [Symbol.toStringTag]() {
     return "loadFromJob";
   }
-  async _fetch() {
-    const headers = {
-      "Authorization": this._authorizationHeader,
-      "Accept": "application/jsonl",
-      "Content-Type": "application/json"
-    };
+  async startJob() {
     const body = {
       "sourceType": "URL",
       "url": this._location
     };
-    const postUrl = `${this._baseUrl}/pipelines/${this._pipelineId}/source?mode=queue&processing=sync`;
-    this._requestLogger.debug("before PATCH %s with url %s as source", postUrl, this._location);
-    const response = await fetch(postUrl, {
+    const session = await this._getSession();
+    const headers = {
+      "Authorization": `Bearer ${session.accessToken}`,
+      "Accept": "application/jsonl",
+      "Content-Type": "application/json"
+    };
+    const patchUrl = `${session.baseUrl.replace(/\/+$/, "")}/pipelines/${session.pipelineId}/source?mode=queue&processing=sync`;
+    this._requestLogger.debug("before PATCH %s with url %s as source", patchUrl, this._location);
+    const response = await this._client.fetch(patchUrl, {
       headers,
       method: "PATCH",
       body: JSON.stringify(body),
@@ -9016,26 +9050,234 @@ var LoadFromJob = class extends AbstractJob {
       // @ts-ignore
       dispatcher: this._dispatcher
     });
-    this._requestLogger.debug("after PATCH %s with url %s as source", postUrl, this._location);
+    this._requestLogger.debug("after PATCH %s with url %s as source", patchUrl, this._location);
     return response;
   }
 };
 
+// src/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);
+  };
+}
+
+// src/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();
+    }
+  }
+};
+
+// src/shims/local_file.ts
+var resolve;
+if ("document" in globalThis && "implementation" in globalThis.document) {
+  const isFileLike = (value) => value != null && typeof value === "object" && typeof value.name === "string" && typeof value.lastModified === "number";
+  resolve = async (params) => {
+    if (params.file) {
+      if (isFileLike(params.file)) {
+        params = {
+          mimeType: params.file.type,
+          file: params.file
+        };
+        return params;
+      }
+    }
+    throw new DOMException("resolving a path to a file is not supported in browser");
+  };
+} else {
+  resolve = async (params) => {
+    if (params.file) {
+      return params;
+    }
+    const mime = require_mime_types();
+    const fs = require("fs");
+    let mimeType;
+    let stream;
+    if (params.filePath) {
+      if (params.mimeType) {
+        mimeType = params.mimeType;
+      } else {
+        mimeType = mime.lookup(params.filePath) || void 0;
+      }
+      stream = fs.createReadStream(params.filePath);
+    }
+    params = {
+      filePath: params.filePath,
+      mimeType,
+      file: stream
+    };
+    return params;
+  };
+}
+
 // src/endpoint.ts
-var fs = __toESM(require("fs"));
-var import_mime_types = __toESM(require_mime_types());
-var import_undici = require("undici");
-var import_await_semaphore = require("await-semaphore");
 var import_pino = require("pino");
-var _Endpoint = class _Endpoint {
+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._dispatcher = null;
-    this._limit = null;
+    this._client = null;
+    this._state = "Idle" /* Idle */;
+    this._stateChangeHandler = null;
+    this._limit = new Semaphore(this._options.jobQueueLength ?? 1024);
     let rootLogger;
     if (options.logger) {
       rootLogger = options.logger;
@@ -9045,56 +9287,79 @@ var _Endpoint = class _Endpoint {
     this._logger = rootLogger.child({ module: "eyepop" });
     this._requestLogger = this._logger.child({ module: "requests" });
   }
-  async upload(params) {
-    if (!this._baseUrl || !this._pipelineId || !this._dispatcher || !this._limit) {
-      return Promise.reject("endpoint not connected, use open() before upload()");
+  onStateChanged(handler) {
+    this._stateChangeHandler = handler;
+    return this;
+  }
+  state() {
+    return this._state;
+  }
+  pendingJobs() {
+    return (this._options.jobQueueLength ?? 1024) - this._limit.getPermits();
+  }
+  popName() {
+    return this._popName;
+  }
+  popId() {
+    return this._options.popId || null;
+  }
+  async session() {
+    await this.currentAccessToken();
+    if (this._token == null || this._expire_token_time == null) {
+      return Promise.reject("endpoint not connected");
     }
-    let mimeType = null;
-    let stream = null;
-    if (params.filePath) {
-      if (params.mimeType) {
-        mimeType = params.mimeType;
-      } else {
-        mimeType = import_mime_types.default.lookup(params.filePath);
+    if (this._baseUrl == null || this._pipelineId == null) {
+      await this.reconnect();
+      if (this._baseUrl == null || this._pipelineId == null) {
+        return Promise.reject("endpoint not connected");
       }
-      stream = fs.createReadStream(params.filePath);
-    } else if (params.stream) {
-      stream = params.stream;
-      mimeType = params.mimeType;
     }
-    if (!mimeType) {
+    return {
+      eyepopUrl: this._options.eyepopUrl,
+      popId: this._options.popId,
+      accessToken: this._token,
+      validUntil: this._expire_token_time * 1e3,
+      baseUrl: this._baseUrl,
+      pipelineId: this._pipelineId
+    };
+  }
+  async upload(params) {
+    if (!this._baseUrl || !this._pipelineId || !this._client || !this._limit) {
+      return Promise.reject("endpoint not connected, use open() before upload()");
+    }
+    params = await resolve(params);
+    if (!params.mimeType) {
       return Promise.reject("upload for streams requires a mimeType");
     }
-    let release = await this._limit.acquire();
-    const job = new UploadJob(
-      stream,
-      mimeType,
-      this._baseUrl,
-      this._pipelineId,
-      await this.authorizationHeader(),
-      this._dispatcher,
-      this._requestLogger
-    );
-    return job.start(release);
+    await this._limit.acquire();
+    this.updateState();
+    const job = new UploadJob(params.file, params.mimeType, async () => {
+      return this.session();
+    }, this._client, this._requestLogger);
+    return job.start(() => {
+      this.jobDone(job);
+    }, (statusCode) => {
+      this.jobStatus(job, statusCode);
+    });
   }
   async loadFrom(location) {
-    if (!this._baseUrl || !this._pipelineId || !this._dispatcher || !this._limit) {
+    if (!this._baseUrl || !this._pipelineId || !this._client || !this._limit) {
       throw new Error("endpoint not connected, use open() before loadFrom()");
     }
-    const release = await this._limit.acquire();
-    const job = new LoadFromJob(
-      location,
-      this._baseUrl,
-      this._pipelineId,
-      await this.authorizationHeader(),
-      this._dispatcher,
-      this._requestLogger
-    );
-    return job.start(release);
+    await this._limit.acquire();
+    this.updateState();
+    const job = new LoadFromJob(location, async () => {
+      return this.session();
+    }, this._client, this._requestLogger);
+    return job.start(() => {
+      this.jobDone(job);
+    }, (statusCode) => {
+      this.jobStatus(job, statusCode);
+    });
   }
   // noinspection TypeScriptValidateTypes
   async connect() {
-    if (this._dispatcher) {
+    if (this._client) {
       console.info("endpoint already connected");
       return this;
     }
@@ -9104,95 +9369,153 @@ var _Endpoint = class _Endpoint {
     if (!this._options.popId) {
       return Promise.reject("option popId or environment variable EYEPOP_POP_ID is required");
     }
-    if (!this._options.secretKey) {
-      return Promise.reject("option secretKey or environment variable EYEPOP_SECRET_KEY is required");
+    if (this._options.auth && this._options.auth.session) {
+      this._token = this._options.auth.session.accessToken;
+      this._expire_token_time = this._options.auth.session.validUntil / 1e3;
+    } else {
+      if (!this._options.auth || !this._options.auth.secretKey) {
+        return Promise.reject("option secretKey or environment variable EYEPOP_SECRET_KEY is required");
+      }
     }
-    this._dispatcher = new import_undici.Agent({
-      keepAliveTimeout: 1e4,
-      pipelining: 100,
-      maxConcurrentStreams: 100,
-      maxCachedSessions: 100,
-      connections: _Endpoint.MAX_CONNECTIONS
-    });
-    this._limit = new import_await_semaphore.Semaphore(this._options.jobQueueLength);
-    const config_url = `${this.eyepopUrl()}/pops/${this._options.popId}/config?auto_start=${this._options.autoStart}`;
+    this._client = await createHttpClient();
+    let result = await this.reconnect();
+    if (this._baseUrl && this._options.stopJobs) {
+      const stop_url = `${this._baseUrl}/pipelines/${this._pipelineId}/source?mode=preempt&processing=sync`;
+      const body = { "sourceType": "NONE" };
+      const headers = {
+        "Authorization": await this.authorizationHeader(),
+        "Content-Type": "application/json"
+      };
+      this._requestLogger.debug("before PATCH %s", stop_url);
+      let response = await this._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}`);
+      }
+      this._requestLogger.debug("after PATCH %s", stop_url);
+    }
+    return result;
+  }
+  jobDone(job) {
+    this._limit?.release();
+    this.updateState();
+  }
+  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);
+    }
+  }
+  jobStatus(job, statusCode) {
+    if (statusCode == 404) {
+      this._pipelineId = null;
+      this._baseUrl = null;
+    } else if (statusCode == 401) {
+      this._token = null;
+      this._expire_token_time = null;
+    }
+  }
+  async reconnect() {
+    if (!this._client) {
+      return Promise.reject("endpoint not initialized");
+    }
+    const 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 fetch(config_url, { headers });
+    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 = {
         "Authorization": await this.authorizationHeader()
       };
-      response = await fetch(config_url, {
-        headers: headers2,
+      this.updateState("FetchConfig" /* FetchConfig */);
+      response = await this._client.fetch(config_url, {
+        headers: headers2
         // @ts-ignore
-        dispatcher: this._dispatcher
       });
     }
     if (response.status != 200) {
+      this.updateState("Error" /* Error */);
       const message = await response.text();
       return Promise.reject(`Unexpected status ${response.status}: ${message}`);
-    }
-    const data = await response.json();
-    const config = data;
-    this._baseUrl = config.base_url;
-    this._pipelineId = config.pipeline_id;
-    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`);
-    }
-    this._baseUrl = this._baseUrl.replace(/\/+$/, "");
-    if (this._options.stopJobs) {
-      const stop_url = `${this._baseUrl}/pipelines/${this._pipelineId}/source?mode=preempt&processing=sync`;
-      const body = { "sourceType": "NONE" };
-      const headers2 = {
-        "Authorization": await this.authorizationHeader(),
-        "Content-Type": "application/json"
-      };
-      this._requestLogger.debug("before PATCH %s", stop_url);
-      let response2 = await fetch(stop_url, { method: "PATCH", headers: headers2, body: JSON.stringify(body) });
-      if (response2.status >= 300) {
-        const message = await response2.text();
-        return Promise.reject(`Unexpected status ${response2.status}: ${message}`);
+    } 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
+          // @ts-ignore
+        });
+        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();
       }
-      this._requestLogger.debug("after PATCH %s", stop_url);
+      this._baseUrl = config.base_url;
+      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`);
+      }
+      this._baseUrl = this._baseUrl.replace(/\/+$/, "");
+      this.updateState();
+      return Promise.resolve(this);
     }
-    return this;
   }
   async disconnect(wait = true) {
     if (wait && this._limit) {
-      for (let i = 0; i < this._options.jobQueueLength; i++) {
+      for (let j = 0; j < this._options.jobQueueLength; j++) {
         await this._limit.acquire();
       }
     }
-    if (this._dispatcher) {
-      await this._dispatcher.close();
-      this._dispatcher = null;
+    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._limit = null;
   }
   async authorizationHeader() {
-    return `Bearer ${await this.accessToken()}`;
+    return `Bearer ${await this.currentAccessToken()}`;
   }
-  async accessToken() {
+  async currentAccessToken() {
     const now = Date.now() / 1e3;
     if (!this._token || this._expire_token_time < now) {
-      const body = { "secret_key": this._options.secretKey };
+      this.updateState("Authenticating" /* Authenticating */);
+      if (!this._client) {
+        return Promise.reject("endpoint not connected");
+      } else if (!this._options.auth || !this._options.auth.secretKey) {
+        return Promise.reject("temporary access token expired");
+      }
+      const body = { "secret_key": this._options.auth.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 fetch(post_url, {
+      const response = await this._client.fetch(post_url, {
         method: "POST",
         headers,
-        body: JSON.stringify(body),
-        // @ts-ignore
-        dispatcher: this._dispatcher
+        body: JSON.stringify(body)
       });
       if (response.status != 200) {
         const message = await response.text();
@@ -9203,6 +9526,7 @@ var _Endpoint = class _Endpoint {
       const token = data;
       this._token = token.access_token;
       this._expire_token_time = now + token.expires_in - 60;
+      this.updateState();
     }
     this._logger.debug("using access token, valid for at least %d seconds", this._expire_token_time - now);
     return this._token;
@@ -9215,8 +9539,6 @@ var _Endpoint = class _Endpoint {
     }
   }
 };
-_Endpoint.MAX_CONNECTIONS = 5;
-var Endpoint = _Endpoint;
 
 // src/visualize.ts
 var _EyePopPlot = class _EyePopPlot {
@@ -9227,17 +9549,19 @@ var _EyePopPlot = class _EyePopPlot {
   }
   prediction(p) {
     if (p && p.objects) {
+      const x_scale = this._context.canvas.width / p.source_width;
+      const y_scale = this._context.canvas.height / p.source_height;
       for (let i = 0; i < p.objects.length; i++) {
-        this.object(p.objects[i]);
+        this.object(p.objects[i], x_scale, y_scale);
       }
     }
   }
-  object(obj) {
+  object(obj, x_scale, y_scale) {
     const context = this._context;
-    const x = obj.x;
-    const y = obj.y;
-    const w = obj.width;
-    const h = obj.height;
+    const x = obj.x * x_scale;
+    const y = obj.y * y_scale;
+    const w = obj.width * x_scale;
+    const h = obj.height * y_scale;
     context.beginPath();
     context.rect(obj.x, obj.y, obj.width, obj.height);
     context.lineWidth = 1;
@@ -9329,10 +9653,50 @@ _EyePopPlot.colors = {
 };
 var EyePopPlot = _EyePopPlot;
 
+// src/shims/browser_session.ts
+var authenticateBrowserSession;
+if ("document" in globalThis && "implementation" in globalThis.document) {
+  authenticateBrowserSession = (oauthUrl, eyepopUrl, popId) => {
+    const queryString = window.location.search;
+    const urlParams = new URLSearchParams(queryString);
+    let token = urlParams.get("pop_token");
+    if (token) {
+      urlParams.delete("pop_token");
+      const url = `${window.location.pathname}?${urlParams}`;
+      window.history.replaceState({}, document.title, url);
+      return {
+        eyepopUrl,
+        popId,
+        accessToken: token,
+        validUntil: Date.now() + 60 * 60 * 1e3
+      };
+    } else {
+      const url = `${oauthUrl}?url=${encodeURIComponent(window.location.href)}`;
+      window.location.replace(url);
+      return {
+        eyepopUrl,
+        popId,
+        accessToken: "in-progress",
+        validUntil: 0
+      };
+    }
+  };
+} else {
+  authenticateBrowserSession = (oauthUrl, eyepopUrl, popId) => {
+    return null;
+  };
+}
+
 // src/index.ts
+var readEnv = (env) => {
+  if (typeof process !== "undefined") {
+    return process.env?.[env] ?? void 0;
+  }
+  return void 0;
+};
 var EyePopSdk = class {
   static endpoint({
-    secretKey = readEnv("EYEPOP_SECRET_KEY"),
+    auth = this.defaultAuth,
     popId = readEnv("EYEPOP_POP_ID"),
     eyepopUrl = readEnv("EYEPOP_URL"),
     autoStart = true,
@@ -9341,10 +9705,17 @@ var EyePopSdk = class {
     logger,
     ...opts
   } = {}) {
+    if (auth.oAuth && popId) {
+      let oauthUrl = "https://dashboard.eyepop.ai/sdkauth";
+      if (typeof auth.oAuth == "string") {
+        oauthUrl = auth.oAuth;
+      }
+      auth.session = authenticateBrowserSession(oauthUrl, eyepopUrl ?? "https://api.eyepop.ai", popId) ?? void 0;
+    }
     const options = {
-      secretKey,
-      popId,
-      eyepopUrl: eyepopUrl ?? "https://api.eyepop.ai",
+      auth,
+      popId: auth.session ? auth.session.popId : popId,
+      eyepopUrl: auth.session ? auth.session.eyepopUrl : eyepopUrl ?? "https://api.eyepop.ai",
       autoStart,
       stopJobs,
       jobQueueLength,
@@ -9357,14 +9728,13 @@ var EyePopSdk = class {
     return new EyePopPlot(context);
   }
 };
-var readEnv = (env) => {
-  if (typeof process !== "undefined") {
-    return process.env?.[env] ?? void 0;
-  }
-  return void 0;
+EyePopSdk.defaultAuth = {
+  secretKey: readEnv("EYEPOP_SECRET_KEY")
 };
+var src_default = EyePopSdk;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  EndpointState,
   EyePopSdk
 });
 /*! Bundled license information: