@eyepop.ai/eyepop 0.10.0 → 0.12.0

package/dist/index.mjs

@@ -8915,7 +8915,7 @@ var AbstractJob = class {
     return Promise.reject("abstract class");
   }
   start(done, status) {
-    this._responseStream = new Promise(async (resolve2, reject) => {
+    this._responseStream = new Promise(async (resolve, reject) => {
       try {
         let retries = 1;
         while (true) {
@@ -8944,7 +8944,7 @@ var AbstractJob = class {
               reject(`response body is empty`);
               break;
             } else {
-              resolve2(response.body);
+              resolve(response.body);
               break;
             }
           } catch (error) {
@@ -9035,6 +9035,39 @@ var LoadFromJob = class extends AbstractJob {
     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": "LIVE_INGRESS",
+      "liveIngressId": this._ingressId
+    };
+    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),
+      signal: this._controller.signal,
+      // @ts-ignore
+      dispatcher: this._dispatcher
+    });
+    this._requestLogger.debug("after PATCH %s with url %s as source", patchUrl, this._ingressId);
+    return response;
+  }
+};
 
 // src/shims/http_client.ts
 var createHttpClient;
@@ -9203,45 +9236,391 @@ var Semaphore = class {
   }
 };
 
-// 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;
+// node_modules/uuid/dist/esm-node/rng.js
+import crypto from "crypto";
+var rnds8Pool = new Uint8Array(256);
+var poolPtr = rnds8Pool.length;
+function rng() {
+  if (poolPtr > rnds8Pool.length - 16) {
+    crypto.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
+import crypto2 from "crypto";
+var native_default = {
+  randomUUID: crypto2.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);
       }
     }
-    throw new DOMException("resolving a path to a file is not supported in browser");
-  };
-} else {
-  resolve = async (params) => {
-    if (params.file) {
-      return params;
+    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 mime = require_mime_types();
-    const fs = __require("fs");
-    let mimeType;
-    let stream;
-    if (params.filePath) {
-      if (params.mimeType) {
-        mimeType = params.mimeType;
+    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 {
-        mimeType = mime.lookup(params.filePath) || void 0;
+        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();
+        }
       }
-      stream = fs.createReadStream(params.filePath);
     }
-    params = {
-      filePath: params.filePath,
-      mimeType,
-      file: stream
+    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 (resolve, reject) => {
+      pc.oniceconnectionstatechange = () => {
+        switch (pc.iceConnectionState) {
+          case "failed":
+          case "disconnected":
+            reject(`peer connection: ${pc.iceConnectionState}`);
+            break;
+          case "connected":
+            resolve(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 resolvePath;
+if ("document" in globalThis && "implementation" in globalThis.document) {
+  resolvePath = async (source) => {
+    throw new DOMException("resolving a path to a file is not supported in browser");
+  };
+} else {
+  resolvePath = async (source) => {
+    const mime = require_mime_types();
+    const filehandle = __require("fs/promises");
+    const fd = await filehandle.open(source.path, "r");
+    const stream = fd.createReadStream();
+    const mimeType = mime.lookup(source.path) || "application/octet-stream";
+    return {
+      stream,
+      mimeType
     };
-    return params;
   };
 }
 
@@ -9258,6 +9637,8 @@ var Endpoint = class {
     this._client = 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) {
@@ -9272,6 +9653,51 @@ var Endpoint = class {
     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;
   }
@@ -9304,39 +9730,130 @@ var Endpoint = class {
       pipelineId: this._pipelineId
     };
   }
-  async upload(params) {
+  async liveIngress(stream) {
+    if (!this._baseUrl || !this._client) {
+      return Promise.reject("endpoint not connected, use connect() before ingress()");
+    }
+    const whip = new Whip(stream, async () => {
+      return this.session();
+    }, this._client, this._requestLogger);
+    return whip.start();
+  }
+  async process(source) {
+    if (source.file !== void 0) {
+      return this.uploadFile(source);
+    } else if (source.stream !== void 0) {
+      return this.uploadStream(source);
+    } else if (source.path !== void 0) {
+      return this.uploadPath(source);
+    } else if (source.url !== void 0) {
+      return this.loadFrom(source);
+    } else if (source.ingressId !== void 0) {
+      return this.loadLiveIngress(source);
+    } else {
+      return Promise.reject("unknown source type");
+    }
+  }
+  async uploadFile(source) {
     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();
+    try {
+      this.updateState();
+      const job = new UploadJob(source.file, source.file.type, 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) {
+    if (!this._baseUrl || !this._pipelineId || !this._client || !this._limit) {
+      return Promise.reject("endpoint not connected, use connect() before upload()");
     }
     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);
-    });
+    try {
+      this.updateState();
+      const job = new UploadJob(source.stream, source.mimeType, 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(location) {
+  async uploadPath(source) {
     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 process()");
     }
     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);
-    });
+    try {
+      this.updateState();
+      const streamSource = await resolvePath(source);
+      const job = new UploadJob(streamSource.stream, streamSource.mimeType, 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) {
+    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, 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) {
+    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, 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;
+    }
   }
   // noinspection TypeScriptValidateTypes
   async connect() {
@@ -9375,6 +9892,9 @@ var Endpoint = class {
       }
       this._requestLogger.debug("after PATCH %s", stop_url);
     }
+    if (!this._ingressEventWs && this._ingressEventHandler) {
+      await this.startIngressWs();
+    }
     return result;
   }
   jobDone(job) {
@@ -9537,7 +10057,7 @@ var _EyePopPlot = class _EyePopPlot {
       }
     }
   }
-  object(obj, x_scale, y_scale) {
+  object(obj, x_scale = 1, y_scale = 1) {
     const context = this._context;
     const x = obj.x * x_scale;
     const y = obj.y * y_scale;