@eyepop.ai/eyepop 0.9.2 → 0.11.0

package/dist/index.js

@@ -8657,10 +8657,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 +8926,13 @@ function readableStreamAsyncIterable(stream) {
 }
 
 // src/jobs.ts
-var _AbstractJob = class _AbstractJob {
-  constructor(baseUrl, pipelineId, authorizationHeader, client, 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._getSession = getSession;
     this._client = client;
     this._requestLogger = requestLogger;
-    this.i = _AbstractJob.n++;
   }
   [Symbol.asyncIterator]() {
     if (!this._responseStream) {
@@ -8933,22 +8943,55 @@ var _AbstractJob = class _AbstractJob {
   async startJob() {
     return Promise.reject("abstract class");
   }
-  start(done) {
-    this._responseStream = new Promise((resolve2, reject) => {
-      const request = this.startJob();
-      request.then((response) => {
-        if (response.status != 200) {
-          reject(`upload error ${response.status}: ${response.text()}`);
-        } else if (!response.body) {
-          reject(`response body is empty`);
-        } else {
-          resolve2(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,24 +8999,24 @@ 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, client, requestLogger) {
-    super(baseUrl, pipelineId, authorizationHeader, client, requestLogger);
+  constructor(stream, mimeType, getSession, client, requestLogger) {
+    super(getSession, client, requestLogger);
     this._uploadStream = stream;
     this._mimeType = mimeType;
   }
   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 this._client.fetch(postUrl, {
       headers,
@@ -8989,26 +9032,60 @@ var UploadJob = class extends AbstractJob {
   }
 };
 var LoadFromJob = class extends AbstractJob {
-  constructor(location, baseUrl, pipelineId, authorizationHeader, client, requestLogger) {
-    super(baseUrl, pipelineId, authorizationHeader, client, requestLogger);
+  constructor(location, getSession, client, requestLogger) {
+    super(getSession, client, requestLogger);
     this._location = location;
   }
   get [Symbol.toStringTag]() {
     return "loadFromJob";
   }
   async startJob() {
+    const body = {
+      "sourceType": "URL",
+      "url": this._location
+    };
+    const session = await this._getSession();
     const headers = {
-      "Authorization": this._authorizationHeader,
+      "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),
+      signal: this._controller.signal,
+      // @ts-ignore
+      dispatcher: this._dispatcher
+    });
+    this._requestLogger.debug("after PATCH %s with url %s as source", patchUrl, this._location);
+    return response;
+  }
+};
+var LoadLiveIngressJob = class extends AbstractJob {
+  constructor(ingressId, getSession, client, requestLogger) {
+    super(getSession, client, requestLogger);
+    this._ingressId = ingressId;
+  }
+  get [Symbol.toStringTag]() {
+    return "loadLiveIngressJob";
+  }
+  async startJob() {
     const body = {
-      "sourceType": "URL",
-      "url": this._location
+      "sourceType": "LIVE_INGRESS",
+      "liveIngressId": this._ingressId
     };
-    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 this._client.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._ingressId);
+    const response = await this._client.fetch(patchUrl, {
       headers,
       method: "PATCH",
       body: JSON.stringify(body),
@@ -9016,7 +9093,7 @@ 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._ingressId);
     return response;
   }
 };
@@ -9051,7 +9128,7 @@ if ("document" in globalThis && "implementation" in globalThis.document) {
     }
   }
   createHttpClient = async () => {
-    const undici = await import("undici");
+    const undici = require("undici");
     const agent = new undici.Agent({
       keepAliveTimeout: 1e4,
       connections: 5
@@ -9188,6 +9265,374 @@ var Semaphore = class {
   }
 };
 
+// node_modules/uuid/dist/esm-node/rng.js
+var import_crypto = __toESM(require("crypto"));
+var rnds8Pool = new Uint8Array(256);
+var poolPtr = rnds8Pool.length;
+function rng() {
+  if (poolPtr > rnds8Pool.length - 16) {
+    import_crypto.default.randomFillSync(rnds8Pool);
+    poolPtr = 0;
+  }
+  return rnds8Pool.slice(poolPtr, poolPtr += 16);
+}
+
+// node_modules/uuid/dist/esm-node/stringify.js
+var byteToHex = [];
+for (let i = 0; i < 256; ++i) {
+  byteToHex.push((i + 256).toString(16).slice(1));
+}
+function unsafeStringify(arr, offset = 0) {
+  return byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + "-" + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + "-" + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + "-" + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + "-" + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]];
+}
+
+// node_modules/uuid/dist/esm-node/native.js
+var import_crypto2 = __toESM(require("crypto"));
+var native_default = {
+  randomUUID: import_crypto2.default.randomUUID
+};
+
+// node_modules/uuid/dist/esm-node/v4.js
+function v4(options, buf, offset) {
+  if (native_default.randomUUID && !buf && !options) {
+    return native_default.randomUUID();
+  }
+  options = options || {};
+  const rnds = options.random || (options.rng || rng)();
+  rnds[6] = rnds[6] & 15 | 64;
+  rnds[8] = rnds[8] & 63 | 128;
+  if (buf) {
+    offset = offset || 0;
+    for (let i = 0; i < 16; ++i) {
+      buf[offset + i] = rnds[i];
+    }
+    return buf;
+  }
+  return unsafeStringify(rnds);
+}
+var v4_default = v4;
+
+// src/web_rtc_base.ts
+var WebRtcBase = class {
+  constructor(getSession, client, requestLogger) {
+    this._pc = null;
+    this._getSession = getSession;
+    this._client = client;
+    this._requestLogger = requestLogger;
+    this._eTag = "";
+    this._queuedCandidates = [];
+    this._offerData = null;
+  }
+  static linkToIceServers(links) {
+    const servers = links !== null ? links.split(", ").map((link) => {
+      const m = link.match(/^<(.+?)>; rel="ice-server"(; username="(.*?)"; credential="(.*?)"; credential-type="password")?/i);
+      if (!m) {
+        return null;
+      }
+      const iceServer = {
+        urls: [m[1]],
+        username: Whip.unquoteCredential(m[3]),
+        credential: Whip.unquoteCredential(m[4])
+        // credentialType: m[3]? "password" : undefined
+      };
+      return iceServer;
+    }) : [];
+    return servers.filter(function(el) {
+      return el != null;
+    });
+  }
+  static editAnswer(answer, videoCodec, audioCodec, videoBitrate, audioBitrate, audioVoice) {
+    const sections = answer.split("m=");
+    for (let i = 0; i < sections.length; i++) {
+      const section = sections[i];
+      if (section.startsWith("video")) {
+        sections[i] = Whip.setVideoBitrate(Whip.setCodec(section, videoCodec), videoBitrate);
+      } else if (section.startsWith("audio")) {
+        sections[i] = Whip.setAudioBitrate(Whip.setCodec(section, audioCodec), audioBitrate, audioVoice);
+      }
+    }
+    return sections.join("m=");
+  }
+  static setCodec(section, codec) {
+    const lines = section.split("\r\n");
+    const lines2 = [];
+    const payloadFormats = [];
+    for (const line of lines) {
+      if (!line.startsWith("a=rtpmap:")) {
+        lines2.push(line);
+      } else {
+        if (codec && line.toLowerCase().includes(codec)) {
+          payloadFormats.push(line.slice("a=rtpmap:".length).split(" ")[0]);
+          lines2.push(line);
+        }
+      }
+    }
+    const lines3 = [];
+    for (const line of lines2) {
+      if (line.startsWith("a=fmtp:")) {
+        if (payloadFormats.includes(line.slice("a=fmtp:".length).split(" ")[0])) {
+          lines3.push(line);
+        }
+      } else if (line.startsWith("a=rtcp-fb:")) {
+        if (payloadFormats.includes(line.slice("a=rtcp-fb:".length).split(" ")[0])) {
+          lines3.push(line);
+        }
+      } else {
+        lines3.push(line);
+      }
+    }
+    return lines3.join("\r\n");
+  }
+  static setVideoBitrate(section, bitrate) {
+    let lines = section.split("\r\n");
+    for (let i = 0; i < lines.length; i++) {
+      if (lines[i].startsWith("c=")) {
+        lines = [...lines.slice(0, i + 1), "b=TIAS:" + (bitrate * 1024).toString(), ...lines.slice(i + 1)];
+        break;
+      }
+    }
+    return lines.join("\r\n");
+  }
+  static setAudioBitrate(section, bitrate, voice) {
+    let opusPayloadFormat = "";
+    let lines = section.split("\r\n");
+    for (let i = 0; i < lines.length; i++) {
+      if (lines[i].startsWith("a=rtpmap:") && lines[i].toLowerCase().includes("opus/")) {
+        opusPayloadFormat = lines[i].slice("a=rtpmap:".length).split(" ")[0];
+        break;
+      }
+    }
+    if (opusPayloadFormat === "") {
+      return section;
+    }
+    for (let i = 0; i < lines.length; i++) {
+      if (lines[i].startsWith("a=fmtp:" + opusPayloadFormat + " ")) {
+        if (voice) {
+          lines[i] = "a=fmtp:" + opusPayloadFormat + " minptime=10;useinbandfec=1;maxaveragebitrate=" + ((bitrate ?? 0) * 1024).toString();
+        } else {
+          lines[i] = "a=fmtp:" + opusPayloadFormat + " maxplaybackrate=48000;stereo=1;sprop-stereo=1;maxaveragebitrate" + ((bitrate ?? 0) * 1024).toString();
+        }
+      }
+    }
+    return lines.join("\r\n");
+  }
+  static parseOffer(offer) {
+    let medias = [];
+    let iceUfrag = "";
+    let icePwd = "";
+    for (const line of offer.split("\r\n")) {
+      if (line.startsWith("m=")) {
+        medias.push(line.slice("m=".length));
+      } else if (iceUfrag === "" && line.startsWith("a=ice-ufrag:")) {
+        iceUfrag = line.slice("a=ice-ufrag:".length);
+      } else if (icePwd === "" && line.startsWith("a=ice-pwd:")) {
+        icePwd = line.slice("a=ice-pwd:".length);
+      }
+    }
+    return {
+      iceUfrag,
+      icePwd,
+      medias
+    };
+  }
+  static generateSdpFragment(offerData, candidates) {
+    const candidatesByMedia = /* @__PURE__ */ new Map();
+    for (const candidate of candidates) {
+      if (candidate.sdpMLineIndex !== null) {
+        const mid2 = candidate.sdpMLineIndex;
+        let matched = candidatesByMedia.get(mid2);
+        if (matched === void 0) {
+          matched = [];
+          candidatesByMedia.set(mid2, matched);
+        }
+        matched.push(candidate);
+      }
+    }
+    let frag = "a=ice-ufrag:" + offerData.iceUfrag + "\r\na=ice-pwd:" + offerData.icePwd + "\r\n";
+    let mid = 0;
+    for (const media of offerData.medias) {
+      let matched = candidatesByMedia.get(mid);
+      if (matched !== void 0) {
+        frag += "m=" + media + "\r\na=mid:" + mid + "\r\n";
+        for (const candidate of matched) {
+          frag += "a=" + candidate.candidate + "\r\n";
+        }
+      }
+      mid++;
+    }
+    return frag;
+  }
+  static unquoteCredential(v) {
+    if (!v) {
+      return "";
+    }
+    return JSON.parse(`"${v}"`);
+  }
+};
+
+// src/whip.ts
+var Whip = class _Whip extends WebRtcBase {
+  constructor(stream, getSession, client, requestLogger) {
+    super(getSession, client, requestLogger);
+    this._ingressId = v4_default().toString();
+    this._stream = stream;
+  }
+  ingressId() {
+    if (!this._ingressId) {
+      throw new Error("not initialized");
+    }
+    return this._ingressId;
+  }
+  async start() {
+    const session = await this._getSession();
+    const ingressUrl = new URL("/liveIngress/whip/" + this._ingressId, session.baseUrl);
+    this._requestLogger.debug("before GET: %s", ingressUrl);
+    const headers = {
+      "Authorization": `Bearer ${session.accessToken}`
+    };
+    const response = await this._client.fetch(ingressUrl, {
+      headers,
+      method: "GET"
+    });
+    if (response.status >= 300) {
+      return Promise.reject(`unknown status code for GET '${ingressUrl}': ${response.status} (${response.statusText})`);
+    }
+    return this.onIceServers(response);
+  }
+  async onIceServers(response) {
+    if (!this._stream) {
+      throw new Error("onIceServers no stream");
+    }
+    const stream = this._stream;
+    const pc = new RTCPeerConnection({
+      iceServers: _Whip.linkToIceServers(response.headers.get("Link"))
+    });
+    this._pc = pc;
+    pc.onicecandidate = (evt) => this.onLocalCandidate(evt);
+    return new Promise(async (resolve2, reject) => {
+      pc.oniceconnectionstatechange = () => {
+        switch (pc.iceConnectionState) {
+          case "failed":
+          case "disconnected":
+            reject(`peer connection: ${pc.iceConnectionState}`);
+            break;
+          case "connected":
+            resolve2(this);
+            break;
+        }
+      };
+      stream.getTracks().forEach((track) => {
+        this._requestLogger.debug("onIceServers our stream has track: %s", track);
+        pc.addTrack(track, stream);
+      });
+      stream.addEventListener("addtrack", (trackEvent) => {
+        this._requestLogger.debug("onIceServers got lazy track: ", trackEvent.track);
+        pc.addTrack(trackEvent.track, stream);
+      });
+      await this.onLocalOffer(await pc.createOffer());
+    });
+  }
+  async onLocalCandidate(evt) {
+    if (evt.candidate !== null) {
+      if (this._eTag === "") {
+        this._queuedCandidates.push(evt.candidate);
+      } else {
+        await this.sendLocalCandidates([evt.candidate]);
+      }
+    }
+    return this;
+  }
+  async onLocalOffer(offer) {
+    if (!this._pc) {
+      throw new Error("onLocalOffer no peer connection");
+    }
+    if (!offer.sdp) {
+      throw new Error("onLocalOffer no sdp");
+    }
+    this._offerData = _Whip.parseOffer(offer.sdp);
+    await this._pc.setLocalDescription(offer);
+    const session = await this._getSession();
+    const ingressUrl = new URL("/liveIngress/whip/" + this._ingressId, session.baseUrl);
+    this._requestLogger.debug("before GET: %s", ingressUrl);
+    const headers = {
+      "Authorization": `Bearer ${session.accessToken}`,
+      "Content-Type": "application/sdp"
+    };
+    const response = await this._client.fetch(ingressUrl, {
+      headers,
+      method: "POST",
+      body: offer.sdp
+    });
+    if (response.status != 201) {
+      return Promise.reject(`unknown status code for POST '${ingressUrl}': ${response.status} (${response.statusText})`);
+    }
+    this._eTag = response.headers.get("ETag") ?? "";
+    return this.onRemoteAnswer(new RTCSessionDescription({
+      type: "answer",
+      sdp: await response.text()
+    }));
+  }
+  async onRemoteAnswer(answer) {
+    if (!this._pc) {
+      throw new Error("onLocalOffer no peer connection");
+    }
+    answer = new RTCSessionDescription({
+      type: "answer",
+      sdp: _Whip.editAnswer(
+        answer.sdp,
+        "h264/90000",
+        void 0,
+        5e3,
+        void 0,
+        true
+      )
+    });
+    await this._pc.setRemoteDescription(new RTCSessionDescription(answer));
+    if (this._queuedCandidates.length !== 0) {
+      await this.sendLocalCandidates(this._queuedCandidates);
+      this._queuedCandidates = [];
+    }
+    return this;
+  }
+  async sendLocalCandidates(candidates) {
+    if (!this._offerData) {
+      throw new Error("sendLocalCandidates no offerData");
+    }
+    const session = await this._getSession();
+    const ingressUrl = new URL("/liveIngress/whip/" + this._ingressId, session.baseUrl);
+    this._requestLogger.debug("before PATCH: %s", ingressUrl);
+    const headers = {
+      "Authorization": `Bearer ${session.accessToken}`,
+      "Content-Type": "application/trickle-ice-sdpfrag",
+      "If-Match": this._eTag
+    };
+    const response = await this._client.fetch(ingressUrl, {
+      headers,
+      method: "PATCH",
+      body: _Whip.generateSdpFragment(this._offerData, candidates)
+    });
+    if (response.status != 204) {
+      return Promise.reject(`unknown status code for PATCH '${ingressUrl}': ${response.status} (${response.statusText})`);
+    }
+    return this;
+  }
+  async close() {
+    const pc = this._pc;
+    const stream = this._stream;
+    this._stream = null;
+    this._pc = null;
+    if (stream) {
+      const tracks = stream.getTracks();
+      tracks.forEach((track) => {
+        track.stop();
+      });
+    }
+    if (pc) {
+      return pc.close();
+    }
+  }
+};
+
 // src/shims/local_file.ts
 var resolve;
 if ("document" in globalThis && "implementation" in globalThis.document) {
@@ -9209,8 +9654,8 @@ if ("document" in globalThis && "implementation" in globalThis.document) {
     if (params.file) {
       return params;
     }
-    const mime = await Promise.resolve().then(() => __toESM(require_mime_types()));
-    const fs = await import("fs");
+    const mime = require_mime_types();
+    const fs = require("fs");
     let mimeType;
     let stream;
     if (params.filePath) {
@@ -9241,7 +9686,11 @@ var Endpoint = class {
     this._token = null;
     this._expire_token_time = null;
     this._client = null;
-    this._limit = null;
+    this._state = "Idle" /* Idle */;
+    this._stateChangeHandler = null;
+    this._ingressEventHandler = null;
+    this._ingressEventWs = null;
+    this._limit = new Semaphore(this._options.jobQueueLength ?? 1024);
     let rootLogger;
     if (options.logger) {
       rootLogger = options.logger;
@@ -9251,57 +9700,143 @@ var Endpoint = class {
     this._logger = rootLogger.child({ module: "eyepop" });
     this._requestLogger = this._logger.child({ module: "requests" });
   }
+  onStateChanged(handler) {
+    this._stateChangeHandler = handler;
+    return this;
+  }
+  async startIngressWs() {
+    if (this._ingressEventWs || !this._baseUrl || !this._client) {
+      return;
+    }
+    try {
+      const getTokenUrl = `${this._baseUrl}/liveIngress/events/token`;
+      const headers = {
+        "Authorization": await this.authorizationHeader()
+      };
+      this._requestLogger.debug("before GET %s", getTokenUrl);
+      let response = await this._client.fetch(getTokenUrl, { headers });
+      if (response.status == 401) {
+        this._requestLogger.debug("after GET %s: 401, about to retry with fresh access token", getTokenUrl);
+        this._token = null;
+        const headers2 = {
+          "Authorization": await this.authorizationHeader()
+        };
+        this.updateState("FetchConfig" /* FetchConfig */);
+        response = await this._client.fetch(getTokenUrl, { headers: headers2 });
+      }
+      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();
+    }
+  }
+  onIngressEvent(handler) {
+    this._ingressEventHandler = handler;
+    this.startIngressWs().then(() => {
+    }).catch((reason) => {
+      this._logger.warn("unexpected error starting the ingress event handler: %s", reason);
+    });
+    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");
     }
-    const token = {
+    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: new Date(this._expire_token_time * 1e3)
+      validUntil: this._expire_token_time * 1e3,
+      baseUrl: this._baseUrl,
+      pipelineId: this._pipelineId
     };
-    return token;
+  }
+  async liveIngress(stream) {
+    if (!this._baseUrl || !this._client) {
+      return Promise.reject("endpoint not connected, use connect() before ingress()");
+    }
+    const job = new Whip(stream, async () => {
+      return this.session();
+    }, this._client, this._requestLogger);
+    return job.start();
   }
   async upload(params) {
     if (!this._baseUrl || !this._pipelineId || !this._client || !this._limit) {
-      return Promise.reject("endpoint not connected, use open() before upload()");
+      return Promise.reject("endpoint not connected, use connect() before upload()");
     }
     params = await resolve(params);
     if (!params.mimeType) {
       return Promise.reject("upload for streams requires a mimeType");
     }
     await this._limit.acquire();
-    const job = new UploadJob(
-      params.file,
-      params.mimeType,
-      this._baseUrl,
-      this._pipelineId,
-      await this.authorizationHeader(),
-      this._client,
-      this._requestLogger
-    );
+    this.updateState();
+    const job = new UploadJob(params.file, params.mimeType, async () => {
+      return this.session();
+    }, this._client, this._requestLogger);
     return job.start(() => {
-      this._limit?.release();
+      this.jobDone(job);
+    }, (statusCode) => {
+      this.jobStatus(job, statusCode);
     });
   }
   async loadFrom(location) {
     if (!this._baseUrl || !this._pipelineId || !this._client || !this._limit) {
-      throw new Error("endpoint not connected, use open() before loadFrom()");
+      throw new Error("endpoint not connected, use connect() before loadFrom()");
     }
     await this._limit.acquire();
-    const job = new LoadFromJob(
-      location,
-      this._baseUrl,
-      this._pipelineId,
-      await this.authorizationHeader(),
-      this._client,
-      this._requestLogger
-    );
+    this.updateState();
+    const job = new LoadFromJob(location, async () => {
+      return this.session();
+    }, this._client, this._requestLogger);
     return job.start(() => {
-      this._limit?.release();
+      this.jobDone(job);
+    }, (statusCode) => {
+      this.jobStatus(job, statusCode);
+    });
+  }
+  async loadLiveIngress(ingressId) {
+    if (!this._baseUrl || !this._pipelineId || !this._client || !this._limit) {
+      throw new Error("endpoint not connected, use connect() before loadLiveIngress()");
+    }
+    await this._limit.acquire();
+    this.updateState();
+    const job = new LoadLiveIngressJob(ingressId, async () => {
+      return this.session();
+    }, this._client, this._requestLogger);
+    return job.start(() => {
+      this.jobDone(job);
+    }, (statusCode) => {
+      this.jobStatus(job, statusCode);
     });
   }
   // noinspection TypeScriptValidateTypes
@@ -9316,20 +9851,72 @@ var Endpoint = class {
     if (!this._options.popId) {
       return Promise.reject("option popId or environment variable EYEPOP_POP_ID is required");
     }
-    if (this._options.session) {
-      this._token = this._options.session.accessToken;
-      this._expire_token_time = this._options.session.validUntil.getTime() / 1e3;
+    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.secretKey) {
+      if (!this._options.auth || !this._options.auth.secretKey) {
         return Promise.reject("option secretKey or environment variable EYEPOP_SECRET_KEY is required");
       }
     }
     this._client = await createHttpClient();
-    this._limit = new Semaphore(this._options.jobQueueLength);
-    const config_url = `${this.eyepopUrl()}/pops/${this._options.popId}/config?auto_start=${this._options.autoStart}`;
+    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);
+    }
+    if (!this._ingressEventWs && this._ingressEventHandler) {
+      await this.startIngressWs();
+    }
+    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 this._client.fetch(config_url, { headers });
     if (response.status == 401) {
@@ -9338,41 +9925,47 @@ var Endpoint = class {
       const headers2 = {
         "Authorization": await this.authorizationHeader()
       };
+      this.updateState("FetchConfig" /* FetchConfig */);
       response = await this._client.fetch(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}`);
-    }
-    const data = await response.json();
-    const config = data;
-    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(/\/+$/, "");
-    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 this._client.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) {
@@ -9380,13 +9973,13 @@ var Endpoint = class {
         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._limit = null;
   }
   async authorizationHeader() {
     return `Bearer ${await this.currentAccessToken()}`;
@@ -9394,12 +9987,13 @@ var Endpoint = class {
   async currentAccessToken() {
     const now = Date.now() / 1e3;
     if (!this._token || this._expire_token_time < now) {
+      this.updateState("Authenticating" /* Authenticating */);
       if (!this._client) {
         return Promise.reject("endpoint not connected");
-      } else if (!this._options.secretKey) {
+      } else if (!this._options.auth || !this._options.auth.secretKey) {
         return Promise.reject("temporary access token expired");
       }
-      const body = { "secret_key": this._options.secretKey };
+      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);
@@ -9417,6 +10011,7 @@ var Endpoint = class {
       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;
@@ -9439,17 +10034,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 = 1, y_scale = 1) {
     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;
@@ -9541,11 +10138,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"),
-    session = void 0,
+    auth = this.defaultAuth,
     popId = readEnv("EYEPOP_POP_ID"),
     eyepopUrl = readEnv("EYEPOP_URL"),
     autoStart = true,
@@ -9554,11 +10190,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,
-      session,
-      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,
@@ -9571,14 +10213,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: