@eyepop.ai/eyepop 1.17.4 → 1.18.0

package/dist/eyepop.index.mjs

@@ -8886,748 +8886,724 @@ var ContourType = /* @__PURE__ */ ((ContourType2) => {
   return ContourType2;
 })(ContourType || {});
 
-// worker/jobs.ts
-var AbstractJob = class {
-  constructor(params, getSession, client, requestLogger) {
-    this._responseStream = null;
-    this._controller = new AbortController();
+// worker/webrtc_whip.ts
+import { v4 as uuidv4 } from "uuid";
+
+// worker/webrtc_base.ts
+import path from "path";
+var WebrtcBase = class _WebrtcBase {
+  constructor(getSession, client, ingressId, urlBasePath, is_pipeline_direct, requestLogger) {
     this._getSession = getSession;
-    this._params = params ?? null;
     this._client = client;
     this._requestLogger = requestLogger;
+    this._ingressId = ingressId;
+    this._urlPath = `${urlBasePath}/${this._ingressId}`;
+    this._is_pipeline_direct = is_pipeline_direct;
+    this._pc = null;
+    this._eTag = "";
+    this._location = null;
+    this._queuedCandidates = [];
+    this._offerData = null;
   }
-  [Symbol.asyncIterator]() {
-    if (!this._responseStream) {
-      throw Error("logical bug");
+  async close() {
+    const pc = this._pc;
+    this._pc = null;
+    if (pc) {
+      return pc.close();
     }
-    return Stream.iterFromReadableStream(this._responseStream, this._controller, async (event) => {
-      return await this.onEvent(event);
-    });
   }
-  async startJob() {
-    return Promise.reject("abstract class");
+  ingressId() {
+    return this._ingressId;
   }
-  async onEvent(event) {
-    if (event.type == "error") {
-      return Promise.reject(`Error event for source ${event.source_id}: ${event.message}`);
+  gresUrl(session, location = null) {
+    let urlPath;
+    if (this._is_pipeline_direct) {
+      if (!session.pipelineId) {
+        throw new Error("cannot connect with is_pipeline_direct=true but !session.pipelineId");
+      }
+      urlPath = path.join("pipelines", session.pipelineId, this._urlPath);
+    } else {
+      urlPath = this._urlPath;
     }
-    return Promise.resolve();
+    if (location) {
+      urlPath = path.join(urlPath, location);
+    }
+    let baseUrl;
+    if (session.baseUrl?.endsWith("/")) {
+      baseUrl = session.baseUrl;
+    } else {
+      baseUrl = session.baseUrl + "/";
+    }
+    return new URL(urlPath, baseUrl);
   }
-  start(done, status) {
-    this._responseStream = new Promise(async (resolve, 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) {
-              resolve(response.body);
-              break;
-            } else {
-              const text = await response.text();
-              if (text) {
-                resolve(readableStreamFromString(text));
-                break;
-              } else {
-                reject("response body is empty");
-                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) {
-        reject(reason);
-      } finally {
-        done();
-      }
+  async onLocalOffer(offer) {
+    if (!this._pc) {
+      throw new Error("onLocalOffer no peer connection");
+    }
+    if (!offer.sdp) {
+      throw new Error("onLocalOffer no sdp");
+    }
+    this._offerData = _WebrtcBase.parseOffer(offer.sdp);
+    await this._pc.setLocalDescription(offer);
+    const session = await this._getSession();
+    const ingressUrl = this.gresUrl(session);
+    const headers = {
+      ...session.authenticationHeaders(),
+      "Content-Type": "application/sdp"
+    };
+    const response = await this._client.fetch(ingressUrl, {
+      headers,
+      method: "POST",
+      body: offer.sdp
     });
-    return this;
-  }
-  cancel() {
-    this._controller.abort("cancelled");
+    if (response.status >= 300) {
+      return Promise.reject(`unknown status code for POST '${ingressUrl}': ${response.status} (${response.statusText})`);
+    }
+    this._eTag = response.headers.get("ETag") ?? "";
+    this._location = response.headers.get("Location");
+    return await this.onRemoteAnswer(new RTCSessionDescription({
+      type: "answer",
+      sdp: await response.text()
+    }));
   }
-};
-AbstractJob.n = 0;
-var UploadJob = class extends AbstractJob {
-  get [Symbol.toStringTag]() {
-    return "uploadJob";
+  async sendLocalCandidates(candidates) {
+    if (!this._offerData) {
+      throw new Error("sendLocalCandidates no offerData");
+    }
+    const session = await this._getSession();
+    const ingressUrl = this.gresUrl(session, this._location);
+    const headers = {
+      ...session.authenticationHeaders(),
+      "Content-Type": "application/trickle-ice-sdpfrag",
+      "If-Match": this._eTag
+    };
+    const response = await this._client.fetch(ingressUrl, {
+      headers,
+      method: "PATCH",
+      body: _WebrtcBase.generateSdpFragment(this._offerData, candidates)
+    });
+    if (response.status >= 300) {
+      return Promise.reject(`unknown status code for PATCH '${ingressUrl}': ${response.status} (${response.statusText})`);
+    }
+    return this;
   }
-  constructor(stream, mimeType, size, videoMode, params, getSession, client, requestLogger) {
-    super(params, getSession, client, requestLogger);
-    this._uploadStream = stream;
-    this._mimeType = mimeType;
-    this._size = size;
-    this._videoMode = videoMode;
-    this._needsFullDuplex = !client.isFullDuplex() && mimeType.startsWith("video/") && videoMode == "stream" /* STREAM */;
+  async onLocalCandidate(evt) {
+    if (evt.candidate !== null) {
+      if (this._eTag === "") {
+        this._queuedCandidates.push(evt.candidate);
+      } else {
+        await this.sendLocalCandidates([evt.candidate]);
+      }
+    }
+    return this;
   }
-  async onEvent(event) {
-    if (event.type == "prepared") {
-      if (!event.source_id) {
-        return Promise.reject("did not get a prepared sourceId to simulate full duplex");
+  static linkToIceServers(links) {
+    const servers = links !== null ? links.split(", ").map((link) => {
+      let m = link.match(/^<(.+?)>; rel="ice-server"(; username="(.*?)"; credential="(.*?)"; credential-type="password")?/i);
+      if (!m) {
+        m = link.match(/^(.+?); rel="ice-server"(; username="(.*?)"; credential="(.*?)"; credential-type="password")?/i);
       }
-      const session = await this._getSession();
-      if (!session.baseUrl) {
-        return Promise.reject("session.baseUrl must not ne null");
+      if (!m) {
+        return null;
       }
-      let request;
-      const videoModeQuery = this._videoMode ? `&videoMode=${this._videoMode}` : "";
-      const postUrl = `${session.baseUrl.replace(/\/+$/, "")}/pipelines/${session.pipelineId}/source?mode=queue&processing=async&sourceId=${event.source_id}${videoModeQuery}`;
-      if (this._params) {
-        const params = JSON.stringify(this._params);
-        const paramBlob = new Blob([params], { type: "application/json" });
-        const formData = new FormData();
-        const fileBlob = await new Response(this._uploadStream).blob();
-        formData.append("params", paramBlob);
-        formData.append("file", fileBlob);
-        const headers = {
-          ...session.authenticationHeaders(),
-          Accept: "application/jsonl"
-        };
-        request = this._client.fetch(postUrl, {
-          headers,
-          method: "POST",
-          body: formData,
-          signal: this._controller.signal,
-          // @ts-ignore
-          duplex: "half",
-          eyepop: { responseStreaming: true }
-        });
+      const iceServer = {
+        urls: [m[1]],
+        username: WebrtcWhip.unquoteCredential(m[3]),
+        credential: WebrtcWhip.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] = WebrtcWhip.setVideoBitrate(WebrtcWhip.setCodec(section, videoCodec), videoBitrate);
+      } else if (section.startsWith("audio")) {
+        sections[i] = WebrtcWhip.setAudioBitrate(WebrtcWhip.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 {
-        const headers = {
-          ...session.authenticationHeaders(),
-          Accept: "application/jsonl",
-          "Content-Type": this._mimeType
-        };
-        if (this._size) {
-          headers["Content-Length"] = `${this._size}`;
+        if (codec && line.toLowerCase().includes(codec)) {
+          payloadFormats.push(line.slice("a=rtpmap:".length).split(" ")[0]);
+          lines2.push(line);
         }
-        request = this._client.fetch(postUrl, {
-          headers,
-          method: "POST",
-          body: this._uploadStream,
-          signal: this._controller.signal,
-          // @ts-ignore
-          duplex: "half",
-          eyepop: { responseStreaming: true }
-        });
       }
-      request.then(async (value) => {
-        if (value.status != 204) {
-          this._requestLogger.debug(`unexpected status ${value.status} (${await value.text()}) for POST ${postUrl}`);
+    }
+    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);
         }
-      }).catch((reason) => {
-        this._requestLogger.debug(`error ${reason} for POST ${postUrl}`);
-      });
+      } 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 Promise.resolve();
+    return lines3.join("\r\n");
   }
-  async startJob() {
-    const session = await this._getSession();
-    if (!session.baseUrl) {
-      return Promise.reject("session.baseUrl must not be null");
+  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;
+      }
     }
-    let response;
-    if (this._needsFullDuplex) {
-      const prepareUrl = `${session.baseUrl.replace(/\/+$/, "")}/pipelines/${session.pipelineId}/prepareSource?timeout=10s`;
-      const headers = {
-        ...session.authenticationHeaders(),
-        Accept: "application/jsonl"
-      };
-      response = await this._client.fetch(prepareUrl, {
-        headers,
-        method: "POST",
-        signal: this._controller.signal,
-        // @ts-ignore
-        duplex: "half",
-        eyepop: { responseStreaming: true }
-      });
-    } else {
-      const videoModeQuery = this._videoMode ? `&videoMode=${this._videoMode}` : "";
-      const postUrl = `${session.baseUrl.replace(/\/+$/, "")}/pipelines/${session.pipelineId}/source?mode=queue&processing=sync${videoModeQuery}`;
-      if (this._params) {
-        const params = JSON.stringify(this._params);
-        const paramBlob = new Blob([params], { type: "application/json" });
-        const formData = new FormData();
-        const fileBlob = await new Response(this._uploadStream).blob();
-        formData.append("params", paramBlob);
-        formData.append("file", fileBlob);
-        const headers = {
-          ...session.authenticationHeaders(),
-          Accept: "application/jsonl"
-        };
-        response = await this._client.fetch(postUrl, {
-          headers,
-          method: "POST",
-          body: formData,
-          signal: this._controller.signal,
-          // @ts-ignore
-          duplex: "half",
-          eyepop: { responseStreaming: true }
-        });
-      } else {
-        const headers = {
-          ...session.authenticationHeaders(),
-          Accept: "application/jsonl",
-          "Content-Type": this._mimeType
-        };
-        if (this._size) {
-          headers["Content-Length"] = `${this._size}`;
+    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();
         }
-        response = await this._client.fetch(postUrl, {
-          headers,
-          method: "POST",
-          body: this._uploadStream,
-          signal: this._controller.signal,
-          // @ts-ignore
-          duplex: "half"
-        });
       }
     }
-    return response;
-  }
-};
-var LoadFromJob = class extends AbstractJob {
-  constructor(location, params, getSession, client, requestLogger) {
-    super(params, getSession, client, requestLogger);
-    this._location = location;
-  }
-  get [Symbol.toStringTag]() {
-    return "loadFromJob";
+    return lines.join("\r\n");
   }
-  async startJob() {
-    const session = await this._getSession();
-    if (!session.baseUrl) {
-      return Promise.reject("session.baseUrl must not ne null");
+  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);
+      }
     }
-    const body = {
-      sourceType: "URL",
-      url: this._location,
-      params: this._params
-    };
-    const headers = {
-      ...session.authenticationHeaders(),
-      Accept: "application/jsonl",
-      "Content-Type": "application/json"
+    return {
+      iceUfrag,
+      icePwd,
+      medias
     };
-    const patchUrl = `${session.baseUrl.replace(/\/+$/, "")}/pipelines/${session.pipelineId}/source?mode=queue&processing=sync`;
-    return await this._client.fetch(patchUrl, {
-      headers,
-      method: "PATCH",
-      body: JSON.stringify(body),
-      signal: this._controller.signal,
-      // @ts-ignore
-      eyepop: { responseStreaming: true }
-    });
-  }
-};
-var LoadFromAssetUuidJob = class extends AbstractJob {
-  constructor(assetUuid, params, getSession, client, requestLogger) {
-    super(params, getSession, client, requestLogger);
-    this._assetUuid = assetUuid;
   }
-  get [Symbol.toStringTag]() {
-    return "loadFromAssetUuidJob";
+  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;
   }
-  async startJob() {
-    const session = await this._getSession();
-    if (!session.baseUrl) {
-      return Promise.reject("session.baseUrl must not ne null");
+  static unquoteCredential(v) {
+    if (!v) {
+      return "";
     }
-    const body = {
-      sourceType: "ASSET_UUID",
-      assetUuid: this._assetUuid,
-      params: this._params
-    };
-    const headers = {
-      ...session.authenticationHeaders(),
-      Accept: "application/jsonl",
-      "Content-Type": "application/json"
-    };
-    const patchUrl = `${session.baseUrl.replace(/\/+$/, "")}/pipelines/${session.pipelineId}/source?mode=queue&processing=sync`;
-    return await this._client.fetch(patchUrl, {
-      headers,
-      method: "PATCH",
-      body: JSON.stringify(body),
-      signal: this._controller.signal,
-      // @ts-ignore
-      eyepop: { responseStreaming: true }
-    });
+    return JSON.parse(`"${v}"`);
   }
 };
-var LoadLiveIngressJob = class extends AbstractJob {
-  constructor(ingressId, params, getSession, client, requestLogger) {
-    super(params, getSession, client, requestLogger);
-    this._ingressId = ingressId;
-  }
-  get [Symbol.toStringTag]() {
-    return "loadLiveIngressJob";
+
+// worker/webrtc_whip.ts
+var WebrtcWhip = class extends WebrtcBase {
+  constructor(stream, getSession, client, is_pipeline_direct, requestLogger) {
+    super(getSession, client, uuidv4().toString(), "liveIngress/whip", is_pipeline_direct, requestLogger);
+    this._stream = stream;
   }
-  async startJob() {
+  async start() {
     const session = await this._getSession();
-    if (!session.baseUrl) {
-      return Promise.reject("session.baseUrl must not ne null");
+    const ingressUrl = this.gresUrl(session);
+    const response = await this._client.fetch(ingressUrl, {
+      headers: session.authenticationHeaders(),
+      method: "GET"
+    });
+    if (response.status >= 300) {
+      return Promise.reject(`unknown status code for GET '${ingressUrl}': ${response.status} (${response.statusText})`);
     }
-    const body = {
-      sourceType: "LIVE_INGRESS",
-      liveIngressId: this._ingressId,
-      params: this._params
-    };
-    const headers = {
-      ...session.authenticationHeaders(),
-      Accept: "application/jsonl",
-      "Content-Type": "application/json"
-    };
-    const patchUrl = `${session.baseUrl.replace(/\/+$/, "")}/pipelines/${session.pipelineId}/source?mode=preempt&processing=sync`;
-    return await this._client.fetch(patchUrl, {
-      headers,
-      method: "PATCH",
-      body: JSON.stringify(body),
-      signal: this._controller.signal,
-      // @ts-ignore
-      eyepop: { responseStreaming: true }
-    });
-  }
-};
-
-// worker/webrtc_whip.ts
-import { v4 as uuidv4 } from "uuid";
-
-// worker/webrtc_base.ts
-import path from "path";
-var WebrtcBase = class _WebrtcBase {
-  constructor(getSession, client, ingressId, urlBasePath, requestLogger) {
-    this._getSession = getSession;
-    this._client = client;
-    this._requestLogger = requestLogger;
-    this._ingressId = ingressId;
-    this._urlPath = `${urlBasePath}/${this._ingressId}`;
-    this._pc = null;
-    this._eTag = "";
-    this._location = null;
-    this._queuedCandidates = [];
-    this._offerData = null;
-  }
-  async close() {
-    const pc = this._pc;
-    this._pc = null;
-    if (pc) {
-      return pc.close();
-    }
-  }
-  ingressId() {
-    return this._ingressId;
+    return await this.onIceServers(response);
   }
-  gresUrl(session, location = null) {
-    let urlPath;
-    if (location) {
-      urlPath = path.join(this._urlPath, location);
-    } else {
-      urlPath = this._urlPath;
-    }
-    let baseUrl;
-    if (session.baseUrl?.endsWith("/")) {
-      baseUrl = session.baseUrl;
+  async stream() {
+    if (this._stream) {
+      return Promise.resolve(this._stream);
     } else {
-      baseUrl = session.baseUrl + "/";
+      return Promise.reject("fetching stream failed");
     }
-    return new URL(urlPath, baseUrl);
   }
-  async onLocalOffer(offer) {
+  async onRemoteAnswer(answer) {
     if (!this._pc) {
       throw new Error("onLocalOffer no peer connection");
     }
-    if (!offer.sdp) {
-      throw new Error("onLocalOffer no sdp");
-    }
-    this._offerData = _WebrtcBase.parseOffer(offer.sdp);
-    await this._pc.setLocalDescription(offer);
-    const session = await this._getSession();
-    const ingressUrl = this.gresUrl(session);
-    const headers = {
-      ...session.authenticationHeaders(),
-      "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})`);
+    await this._pc.setRemoteDescription(new RTCSessionDescription(answer));
+    if (this._queuedCandidates.length !== 0) {
+      await this.sendLocalCandidates(this._queuedCandidates);
+      this._queuedCandidates = [];
     }
-    this._eTag = response.headers.get("ETag") ?? "";
-    this._location = response.headers.get("Location");
-    return await this.onRemoteAnswer(new RTCSessionDescription({
-      type: "answer",
-      sdp: await response.text()
-    }));
+    return this;
   }
-  async sendLocalCandidates(candidates) {
-    if (!this._offerData) {
-      throw new Error("sendLocalCandidates no offerData");
+  async onIceServers(response) {
+    if (!this._stream) {
+      throw new Error("onIceServers no stream");
     }
-    const session = await this._getSession();
-    const ingressUrl = this.gresUrl(session, this._location);
-    const headers = {
-      ...session.authenticationHeaders(),
-      "Content-Type": "application/trickle-ice-sdpfrag",
-      "If-Match": this._eTag
-    };
-    const response = await this._client.fetch(ingressUrl, {
-      headers,
-      method: "PATCH",
-      body: _WebrtcBase.generateSdpFragment(this._offerData, candidates)
+    const stream = this._stream;
+    const pc = new RTCPeerConnection({
+      iceServers: WebrtcBase.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());
     });
-    if (response.status != 204) {
-      return Promise.reject(`unknown status code for PATCH '${ingressUrl}': ${response.status} (${response.statusText})`);
-    }
-    return this;
   }
-  async onLocalCandidate(evt) {
-    if (evt.candidate !== null) {
-      if (this._eTag === "") {
-        this._queuedCandidates.push(evt.candidate);
-      } else {
-        await this.sendLocalCandidates([evt.candidate]);
-      }
+  async close() {
+    const stream = this._stream;
+    this._stream = null;
+    if (stream) {
+      const tracks = stream.getTracks();
+      tracks.forEach((track) => {
+        track.stop();
+      });
     }
-    return this;
+    return super.close();
   }
-  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: WebrtcWhip.unquoteCredential(m[3]),
-        credential: WebrtcWhip.unquoteCredential(m[4])
-        // credentialType: m[3]? "password" : undefined
-      };
-      return iceServer;
-    }) : [];
-    return servers.filter(function(el) {
-      return el != null;
-    });
+};
+
+// worker/jobs.ts
+var AbstractJob = class {
+  constructor(params, getSession, client, requestLogger) {
+    this._responseStream = null;
+    this._controller = new AbortController();
+    this._getSession = getSession;
+    this._params = params ?? null;
+    this._client = client;
+    this._requestLogger = requestLogger;
   }
-  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] = WebrtcWhip.setVideoBitrate(WebrtcWhip.setCodec(section, videoCodec), videoBitrate);
-      } else if (section.startsWith("audio")) {
-        sections[i] = WebrtcWhip.setAudioBitrate(WebrtcWhip.setCodec(section, audioCodec), audioBitrate, audioVoice);
-      }
+  [Symbol.asyncIterator]() {
+    if (!this._responseStream) {
+      throw Error("logical bug");
     }
-    return sections.join("m=");
+    return Stream.iterFromReadableStream(this._responseStream, this._controller, async (event) => {
+      return await this.onEvent(event);
+    });
   }
-  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);
-        }
-      }
+  async startJob() {
+    return Promise.reject("abstract class");
+  }
+  async onEvent(event) {
+    if (event.type == "error") {
+      return Promise.reject(`Error event for source ${event.source_id}: ${event.message}`);
     }
-    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);
+    return Promise.resolve();
+  }
+  start(done, status) {
+    this._responseStream = new Promise(async (resolve, 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) {
+              resolve(response.body);
+              break;
+            } else {
+              const text = await response.text();
+              if (text) {
+                resolve(readableStreamFromString(text));
+                break;
+              } else {
+                reject("response body is empty");
+                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;
+            }
+          }
         }
-      } else {
-        lines3.push(line);
+      } catch (reason) {
+        reject(reason);
+      } finally {
+        done();
       }
-    }
-    return lines3.join("\r\n");
+    });
+    return this;
   }
-  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");
+  cancel() {
+    this._controller.abort("cancelled");
   }
-  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;
+};
+AbstractJob.n = 0;
+var UploadJob = class extends AbstractJob {
+  get [Symbol.toStringTag]() {
+    return "uploadJob";
+  }
+  constructor(stream, mimeType, size, videoMode, params, getSession, client, requestLogger) {
+    super(params, getSession, client, requestLogger);
+    this._uploadStream = stream;
+    this._mimeType = mimeType;
+    this._size = size;
+    this._videoMode = videoMode;
+    this._needsFullDuplex = !client.isFullDuplex() && mimeType.startsWith("video/") && videoMode == "stream" /* STREAM */;
+  }
+  async onEvent(event) {
+    if (event.type == "prepared") {
+      if (!event.source_id) {
+        return Promise.reject("did not get a prepared sourceId to simulate full duplex");
       }
-    }
-    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();
+      const session = await this._getSession();
+      if (!session.baseUrl) {
+        return Promise.reject("session.baseUrl must not ne null");
+      }
+      let request;
+      const videoModeQuery = this._videoMode ? `&videoMode=${this._videoMode}` : "";
+      const postUrl = `${session.baseUrl.replace(/\/+$/, "")}/pipelines/${session.pipelineId}/source?mode=queue&processing=async&sourceId=${event.source_id}${videoModeQuery}`;
+      if (this._params) {
+        const params = JSON.stringify(this._params);
+        const paramBlob = new Blob([params], { type: "application/json" });
+        const formData = new FormData();
+        const fileBlob = await new Response(this._uploadStream).blob();
+        formData.append("params", paramBlob);
+        formData.append("file", fileBlob);
+        const headers = {
+          ...session.authenticationHeaders(),
+          Accept: "application/jsonl"
+        };
+        request = this._client.fetch(postUrl, {
+          headers,
+          method: "POST",
+          body: formData,
+          signal: this._controller.signal,
+          // @ts-ignore
+          duplex: "half",
+          eyepop: { responseStreaming: true }
+        });
+      } else {
+        const headers = {
+          ...session.authenticationHeaders(),
+          Accept: "application/jsonl",
+          "Content-Type": this._mimeType
+        };
+        if (this._size) {
+          headers["Content-Length"] = `${this._size}`;
         }
+        request = this._client.fetch(postUrl, {
+          headers,
+          method: "POST",
+          body: this._uploadStream,
+          signal: this._controller.signal,
+          // @ts-ignore
+          duplex: "half",
+          eyepop: { responseStreaming: true }
+        });
       }
+      request.then(async (value) => {
+        if (value.status != 204) {
+          this._requestLogger.debug(`unexpected status ${value.status} (${await value.text()}) for POST ${postUrl}`);
+        }
+      }).catch((reason) => {
+        this._requestLogger.debug(`error ${reason} for POST ${postUrl}`);
+      });
     }
-    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
-    };
+    return Promise.resolve();
   }
-  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);
-      }
+  async startJob() {
+    const session = await this._getSession();
+    if (!session.baseUrl) {
+      return Promise.reject("session.baseUrl must not be null");
     }
-    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";
+    let response;
+    if (this._needsFullDuplex) {
+      const prepareUrl = `${session.baseUrl.replace(/\/+$/, "")}/pipelines/${session.pipelineId}/prepareSource?timeout=10s`;
+      const headers = {
+        ...session.authenticationHeaders(),
+        Accept: "application/jsonl"
+      };
+      response = await this._client.fetch(prepareUrl, {
+        headers,
+        method: "POST",
+        signal: this._controller.signal,
+        // @ts-ignore
+        duplex: "half",
+        eyepop: { responseStreaming: true }
+      });
+    } else {
+      const videoModeQuery = this._videoMode ? `&videoMode=${this._videoMode}` : "";
+      const postUrl = `${session.baseUrl.replace(/\/+$/, "")}/pipelines/${session.pipelineId}/source?mode=queue&processing=sync${videoModeQuery}`;
+      if (this._params) {
+        const params = JSON.stringify(this._params);
+        const paramBlob = new Blob([params], { type: "application/json" });
+        const formData = new FormData();
+        const fileBlob = await new Response(this._uploadStream).blob();
+        formData.append("params", paramBlob);
+        formData.append("file", fileBlob);
+        const headers = {
+          ...session.authenticationHeaders(),
+          Accept: "application/jsonl"
+        };
+        response = await this._client.fetch(postUrl, {
+          headers,
+          method: "POST",
+          body: formData,
+          signal: this._controller.signal,
+          // @ts-ignore
+          duplex: "half",
+          eyepop: { responseStreaming: true }
+        });
+      } else {
+        const headers = {
+          ...session.authenticationHeaders(),
+          Accept: "application/jsonl",
+          "Content-Type": this._mimeType
+        };
+        if (this._size) {
+          headers["Content-Length"] = `${this._size}`;
         }
+        response = await this._client.fetch(postUrl, {
+          headers,
+          method: "POST",
+          body: this._uploadStream,
+          signal: this._controller.signal,
+          // @ts-ignore
+          duplex: "half"
+        });
       }
-      mid++;
-    }
-    return frag;
-  }
-  static unquoteCredential(v) {
-    if (!v) {
-      return "";
     }
-    return JSON.parse(`"${v}"`);
+    return response;
   }
 };
-
-// worker/webrtc_whip.ts
-var WebrtcWhip = class extends WebrtcBase {
-  constructor(stream, getSession, client, requestLogger) {
-    super(getSession, client, uuidv4().toString(), "liveIngress/whip", requestLogger);
-    this._stream = stream;
+var LoadFromJob = class extends AbstractJob {
+  constructor(location, params, getSession, client, requestLogger) {
+    super(params, getSession, client, requestLogger);
+    this._location = location;
   }
-  async start() {
-    const session = await this._getSession();
-    const ingressUrl = this.gresUrl(session);
-    const response = await this._client.fetch(ingressUrl, {
-      headers: session.authenticationHeaders(),
-      method: "GET"
-    });
-    if (response.status >= 300) {
-      return Promise.reject(`unknown status code for GET '${ingressUrl}': ${response.status} (${response.statusText})`);
-    }
-    return await this.onIceServers(response);
+  get [Symbol.toStringTag]() {
+    return "loadFromJob";
   }
-  async stream() {
-    if (this._stream) {
-      return Promise.resolve(this._stream);
-    } else {
-      return Promise.reject("fetching stream failed");
+  async startJob() {
+    const session = await this._getSession();
+    if (!session.baseUrl) {
+      return Promise.reject("session.baseUrl must not ne null");
     }
+    const body = {
+      sourceType: "URL",
+      url: this._location,
+      params: this._params
+    };
+    const headers = {
+      ...session.authenticationHeaders(),
+      Accept: "application/jsonl",
+      "Content-Type": "application/json"
+    };
+    const patchUrl = `${session.baseUrl.replace(/\/+$/, "")}/pipelines/${session.pipelineId}/source?mode=queue&processing=sync`;
+    return await this._client.fetch(patchUrl, {
+      headers,
+      method: "PATCH",
+      body: JSON.stringify(body),
+      signal: this._controller.signal,
+      // @ts-ignore
+      eyepop: { responseStreaming: true }
+    });
   }
-  async onRemoteAnswer(answer) {
-    if (!this._pc) {
-      throw new Error("onLocalOffer no peer connection");
-    }
-    await this._pc.setRemoteDescription(new RTCSessionDescription(answer));
-    if (this._queuedCandidates.length !== 0) {
-      await this.sendLocalCandidates(this._queuedCandidates);
-      this._queuedCandidates = [];
-    }
-    return this;
+};
+var LoadFromAssetUuidJob = class extends AbstractJob {
+  constructor(assetUuid, params, getSession, client, requestLogger) {
+    super(params, getSession, client, requestLogger);
+    this._assetUuid = assetUuid;
   }
-  async onIceServers(response) {
-    if (!this._stream) {
-      throw new Error("onIceServers no stream");
-    }
-    const stream = this._stream;
-    const pc = new RTCPeerConnection({
-      iceServers: WebrtcBase.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());
-    });
+  get [Symbol.toStringTag]() {
+    return "loadFromAssetUuidJob";
   }
-  async close() {
-    const stream = this._stream;
-    this._stream = null;
-    if (stream) {
-      const tracks = stream.getTracks();
-      tracks.forEach((track) => {
-        track.stop();
-      });
+  async startJob() {
+    const session = await this._getSession();
+    if (!session.baseUrl) {
+      return Promise.reject("session.baseUrl must not ne null");
     }
-    return super.close();
+    const body = {
+      sourceType: "ASSET_UUID",
+      assetUuid: this._assetUuid,
+      params: this._params
+    };
+    const headers = {
+      ...session.authenticationHeaders(),
+      Accept: "application/jsonl",
+      "Content-Type": "application/json"
+    };
+    const patchUrl = `${session.baseUrl.replace(/\/+$/, "")}/pipelines/${session.pipelineId}/source?mode=queue&processing=sync`;
+    return await this._client.fetch(patchUrl, {
+      headers,
+      method: "PATCH",
+      body: JSON.stringify(body),
+      signal: this._controller.signal,
+      // @ts-ignore
+      eyepop: { responseStreaming: true }
+    });
   }
 };
-
-// worker/webrtc_whep.ts
-var WebrtcWhep = class extends WebrtcBase {
-  constructor(ingressId, getSession, client, requestLogger) {
-    super(getSession, client, ingressId, "liveIngress/whep", requestLogger);
-    this._stream = null;
-  }
-  async close() {
-    const stream = this._stream;
-    this._stream = null;
-    if (stream) {
-      const tracks = stream.getTracks();
-      tracks.forEach((track) => {
-        track.stop();
-      });
-    }
-    return super.close();
+var LoadLiveIngressJob = class extends AbstractJob {
+  constructor(ingressId, params, getSession, client, requestLogger) {
+    super(params, getSession, client, requestLogger);
+    this._ingressId = ingressId;
   }
-  async stream() {
-    if (this._stream) {
-      return Promise.resolve(this._stream);
-    } else {
-      return Promise.reject("fetching stream failed");
-    }
+  get [Symbol.toStringTag]() {
+    return "loadLiveIngressJob";
   }
-  async start() {
+  async startJob() {
     const session = await this._getSession();
-    const egressUrl = this.gresUrl(session);
-    const response = await this._client.fetch(egressUrl, {
-      headers: session.authenticationHeaders(),
-      method: "GET"
-    });
-    if (response.status >= 300) {
-      return Promise.reject(`unknown status code for GET '${egressUrl}': ${response.status} (${response.statusText})`);
+    if (!session.baseUrl) {
+      return Promise.reject("session.baseUrl must not ne null");
     }
-    return this.onIceServers(response);
+    const body = {
+      sourceType: "LIVE_INGRESS",
+      liveIngressId: this._ingressId,
+      params: this._params
+    };
+    const headers = {
+      ...session.authenticationHeaders(),
+      Accept: "application/jsonl",
+      "Content-Type": "application/json"
+    };
+    const patchUrl = `${session.baseUrl.replace(/\/+$/, "")}/pipelines/${session.pipelineId}/source?mode=preempt&processing=sync`;
+    return await this._client.fetch(patchUrl, {
+      headers,
+      method: "PATCH",
+      body: JSON.stringify(body),
+      signal: this._controller.signal,
+      // @ts-ignore
+      eyepop: { responseStreaming: true }
+    });
   }
-  async onRemoteAnswer(answer) {
-    if (!this._pc) {
-      throw new Error("onLocalOffer no peer connection");
-    }
-    await this._pc.setRemoteDescription(new RTCSessionDescription(answer));
-    if (this._queuedCandidates.length !== 0) {
-      await this.sendLocalCandidates(this._queuedCandidates);
-      this._queuedCandidates = [];
-    }
-    return this;
+};
+var LoadMediaStreamJob = class extends AbstractJob {
+  constructor(mediaStream, params, getSession, client, requestLogger) {
+    super(params, getSession, client, requestLogger);
+    this._mediaStream = mediaStream;
   }
-  async onIceServers(response) {
-    if (this._stream) {
-      throw new Error("onIceServers has stream");
+  get [Symbol.toStringTag]() {
+    return "loadLiveIngressJob";
+  }
+  async startJob() {
+    const session = await this._getSession();
+    if (!session.baseUrl) {
+      return Promise.reject("session.baseUrl must not ne null");
     }
-    const pc = new RTCPeerConnection({
-      iceServers: WebrtcBase.linkToIceServers(response.headers.get("Link"))
+    const whip = new WebrtcWhip(
+      this._mediaStream,
+      async () => {
+        return session;
+      },
+      this._client,
+      true,
+      this._requestLogger
+    );
+    whip.start().then((value) => {
+      this._requestLogger.debug("direct whip for ingressId=%s successful", whip.ingressId());
+    }).catch((reason) => {
+      this._controller.abort(reason);
     });
-    const direction = "sendrecv";
-    pc.addTransceiver("video", { direction });
-    pc.onicecandidate = (evt) => this.onLocalCandidate(evt);
-    this._pc = pc;
-    this._requestLogger.info(`onIceServers ${pc.iceConnectionState}`);
-    return new Promise(async (resolve, reject) => {
-      pc.ontrack = (evt) => {
-        this._requestLogger.debug(`new track: ${evt.track.kind}`);
-        this._stream = evt.streams[0];
-        resolve(this);
-      };
-      pc.oniceconnectionstatechange = () => {
-        switch (pc.iceConnectionState) {
-          case "failed":
-          case "disconnected":
-            this._requestLogger.debug("oniceconnectionstatechange disconnected");
-            reject(`peer connection: ${pc.iceConnectionState}`);
-            break;
-          case "connected":
-            this._requestLogger.debug("oniceconnectionstatechange connected");
-            break;
-        }
-      };
-      await this.onLocalOffer(await pc.createOffer());
+    const body = {
+      sourceType: "WHIP",
+      whipIngressId: whip.ingressId(),
+      params: this._params
+    };
+    const headers = {
+      ...session.authenticationHeaders(),
+      Accept: "application/jsonl",
+      "Content-Type": "application/json"
+    };
+    const patchUrl = `${session.baseUrl.replace(/\/+$/, "")}/pipelines/${session.pipelineId}/source?mode=preempt&processing=sync`;
+    return await this._client.fetch(patchUrl, {
+      headers,
+      method: "PATCH",
+      body: JSON.stringify(body),
+      signal: this._controller.signal,
+      // @ts-ignore
+      eyepop: { responseStreaming: true }
     });
   }
 };
@@ -10141,8 +10117,6 @@ var WorkerEndpoint = class extends Endpoint {
     this._pipelineId = null;
     this._popName = null;
     this._pipeline = null;
-    this._ingressEventHandler = null;
-    this._ingressEventWs = null;
     this._sandboxId = null;
     const sessionAuth = options.auth;
     if (sessionAuth !== void 0 && sessionAuth.session !== void 0) {
@@ -10168,7 +10142,7 @@ var WorkerEndpoint = class extends Endpoint {
       });
       if (response?.status != 204) {
         const message = await response?.text();
-        this._logger.info(`stoppping pipeline failed, status ${response?.status}: ${message}`);
+        this._logger.info(`stopping pipeline failed, status ${response?.status}: ${message}`);
       }
     }
     if (this._sandboxId && this._baseUrl) {
@@ -10342,42 +10316,6 @@ var WorkerEndpoint = class extends Endpoint {
   popId() {
     return this.options().popId || null;
   }
-  onIngressEvent(handler) {
-    this._ingressEventHandler = handler;
-    this.startIngressWs().then(() => {
-    }).catch((reason) => {
-      this._logger.warn("unexpected error starting the ingress event handler: %s", reason);
-    });
-    return this;
-  }
-  async liveIngress(stream) {
-    if (!this._baseUrl || !this._client) {
-      return Promise.reject("endpoint not connected, use connect()");
-    }
-    const whip = new WebrtcWhip(
-      stream,
-      async () => {
-        return this.session();
-      },
-      this._client,
-      this._requestLogger
-    );
-    return whip.start();
-  }
-  async liveEgress(ingressId) {
-    if (!this._baseUrl || !this._client) {
-      return Promise.reject("endpoint not connected, use connect()");
-    }
-    const whep = new WebrtcWhep(
-      ingressId,
-      async () => {
-        return this.session();
-      },
-      this._client,
-      this._requestLogger
-    );
-    return whep.start();
-  }
   async process(source, params) {
     if (source.file !== void 0) {
       return this.uploadFile(source, params);
@@ -10387,45 +10325,14 @@ var WorkerEndpoint = class extends Endpoint {
       return this.uploadPath(source, params);
     } else if (source.url !== void 0) {
       return this.loadFrom(source, params);
-    } else if (source.ingressId !== void 0) {
-      return this.loadLiveIngress(source, params);
     } else if (source.assetUuid !== void 0) {
       return this.loadFromAssetUuid(source, params);
+    } else if (source.mediaStream !== void 0) {
+      return this.loadMediaStream(source, params);
     } else {
       return Promise.reject("unknown source type");
     }
   }
-  async startIngressWs() {
-    const client = this._client;
-    if (this._ingressEventWs || !this._baseUrl || !client) {
-      return;
-    }
-    try {
-      const session = await this.session();
-      let response = await this.fetchWithRetry(async () => {
-        const headers = {
-          ...this._authenticationHeaders(session)
-        };
-        const getTokenUrl = `${session.baseUrl}/liveIngress/events/token`;
-        return client.fetch(getTokenUrl, { headers });
-      });
-      if (response.status != 200) {
-        const message = await response.text();
-        return Promise.reject(`Unexpected status ${response.status}: ${message}`);
-      }
-      const wsAuthToken = await response.json();
-      const wsUrl = this._baseUrl.startsWith("https://") ? `${this._baseUrl.replace("https://", "wss://")}/liveIngress/events/${wsAuthToken.token}` : `${this._baseUrl.replace("http://", "ws://")}/liveIngress/events/${wsAuthToken.token}`;
-      this._ingressEventWs = new WebSocket(wsUrl);
-      this._ingressEventWs.addEventListener("message", (event) => {
-        const ingressEvent = JSON.parse(event.data);
-        if (this._ingressEventHandler) {
-          this._ingressEventHandler(ingressEvent);
-        }
-      });
-    } finally {
-      this.updateState();
-    }
-  }
   async uploadFile(source, params) {
     if (!this._baseUrl || !this._pipelineId || !this._client || !this._limit) {
       return Promise.reject("endpoint not connected, use connect()");
@@ -10591,15 +10498,15 @@ var WorkerEndpoint = class extends Endpoint {
       throw e;
     }
   }
-  async loadLiveIngress(source, params) {
+  async loadMediaStream(source, params) {
     if (!this._baseUrl || !this._pipelineId || !this._client || !this._limit) {
       throw new Error("endpoint not connected, use connect()");
     }
     await this._limit.acquire();
     try {
       this.updateState();
-      const job = new LoadLiveIngressJob(
-        source.ingressId,
+      const job = new LoadMediaStreamJob(
+        source.mediaStream,
         params,
         async () => {
           return this.session();
@@ -10747,9 +10654,6 @@ var WorkerEndpoint = class extends Endpoint {
         }
       }
     }
-    if (!this._ingressEventWs && this._ingressEventHandler) {
-      await this.startIngressWs();
-    }
     this.updateState();
     return Promise.resolve(this);
   }
@@ -11658,6 +11562,88 @@ var DataEndpoint = class extends Endpoint {
   }
 };
 
+// worker/webrtc_whep.ts
+var WebrtcWhep = class extends WebrtcBase {
+  constructor(ingressId, getSession, client, requestLogger) {
+    super(getSession, client, ingressId, "liveIngress/whep", false, requestLogger);
+    this._stream = null;
+  }
+  async close() {
+    const stream = this._stream;
+    this._stream = null;
+    if (stream) {
+      const tracks = stream.getTracks();
+      tracks.forEach((track) => {
+        track.stop();
+      });
+    }
+    return super.close();
+  }
+  async stream() {
+    if (this._stream) {
+      return Promise.resolve(this._stream);
+    } else {
+      return Promise.reject("fetching stream failed");
+    }
+  }
+  async start() {
+    const session = await this._getSession();
+    const egressUrl = this.gresUrl(session);
+    const response = await this._client.fetch(egressUrl, {
+      headers: session.authenticationHeaders(),
+      method: "GET"
+    });
+    if (response.status >= 300) {
+      return Promise.reject(`unknown status code for GET '${egressUrl}': ${response.status} (${response.statusText})`);
+    }
+    return this.onIceServers(response);
+  }
+  async onRemoteAnswer(answer) {
+    if (!this._pc) {
+      throw new Error("onLocalOffer no peer connection");
+    }
+    await this._pc.setRemoteDescription(new RTCSessionDescription(answer));
+    if (this._queuedCandidates.length !== 0) {
+      await this.sendLocalCandidates(this._queuedCandidates);
+      this._queuedCandidates = [];
+    }
+    return this;
+  }
+  async onIceServers(response) {
+    if (this._stream) {
+      throw new Error("onIceServers has stream");
+    }
+    const pc = new RTCPeerConnection({
+      iceServers: WebrtcBase.linkToIceServers(response.headers.get("Link"))
+    });
+    const direction = "sendrecv";
+    pc.addTransceiver("video", { direction });
+    pc.onicecandidate = (evt) => this.onLocalCandidate(evt);
+    this._pc = pc;
+    this._requestLogger.info(`onIceServers ${pc.iceConnectionState}`);
+    return new Promise(async (resolve, reject) => {
+      pc.ontrack = (evt) => {
+        this._requestLogger.debug(`new track: ${evt.track.kind}`);
+        this._stream = evt.streams[0];
+        resolve(this);
+      };
+      pc.oniceconnectionstatechange = () => {
+        switch (pc.iceConnectionState) {
+          case "failed":
+          case "disconnected":
+            this._requestLogger.debug("oniceconnectionstatechange disconnected");
+            reject(`peer connection: ${pc.iceConnectionState}`);
+            break;
+          case "connected":
+            this._requestLogger.debug("oniceconnectionstatechange connected");
+            break;
+        }
+      };
+      await this.onLocalOffer(await pc.createOffer());
+    });
+  }
+};
+
 // index.ts
 var readEnv = (env) => {
   if (typeof process !== "undefined") {
@@ -11792,6 +11778,7 @@ export {
   LoadFromAssetUuidJob,
   LoadFromJob,
   LoadLiveIngressJob,
+  LoadMediaStreamJob,
   ModelExportStatus,
   ModelFormat,
   ModelPrecisionType,