@eyepop.ai/eyepop 3.16.0 → 3.17.0

package/dist/eyepop.index.mjs

@@ -8632,6 +8632,204 @@ var require_mime_types = __commonJS({
   }
 });
 
+// compute/compute_session.ts
+var SESSION_DEAD = /* @__PURE__ */ new Set(["error" /* ERROR */, "failed" /* FAILED */, "stopped" /* STOPPED */, "pipeline_error" /* PIPELINE_ERROR */, "unknown" /* UNKNOWN */]);
+var CHECK_FOR_IS_READY_INTERVAL = 250;
+var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+function pipelineIdFromSession(session) {
+  if (session.pipeline_uuid) {
+    return session.pipeline_uuid;
+  }
+  const pipeline = session.pipelines?.[0];
+  return pipeline?.id || pipeline?.pipeline_id || null;
+}
+function sessionCreateBody(options) {
+  const body = {};
+  if (options.sessionName) {
+    body.session_name = options.sessionName;
+  }
+  if (options.pipelineImage) {
+    body.pipeline_image = options.pipelineImage;
+  }
+  if (options.pipelineVersion) {
+    body.pipeline_version = options.pipelineVersion;
+  }
+  if (options.pop) {
+    body.pop = options.pop;
+  }
+  return Object.keys(body).length > 0 ? JSON.stringify(body) : void 0;
+}
+function sessionHealthReady(body, contentType) {
+  if (contentType.includes("application/json")) {
+    const health = JSON.parse(body);
+    if (health && typeof health == "object") {
+      if (health.message && !health.session_status) {
+        return true;
+      }
+      return health.session_status == "running" /* RUNNING */;
+    }
+  }
+  return contentType.includes("text/plain") && body.includes("I'm fine");
+}
+function accessTokenValidUntil(session) {
+  if (session.access_token_expires_at) {
+    const expiresAt = Date.parse(session.access_token_expires_at);
+    return Number.isNaN(expiresAt) ? null : expiresAt;
+  }
+  if (session.access_token_expires_in) {
+    return Date.now() + session.access_token_expires_in * 1e3;
+  }
+  return null;
+}
+var ComputeSessionClient = class {
+  constructor(options) {
+    this.options = options;
+  }
+  async resolve() {
+    const session = this.options.sessionUuid ? await this.getPermanentComputeSession(this.options.sessionUuid) : await this.getOnDemandComputeSession();
+    const accessToken = this.sessionAccessToken(session);
+    await this.waitUntilReady(session, accessToken);
+    const pipelineId = pipelineIdFromSession(session);
+    if (this.options.pop && !pipelineId) {
+      throw new Error("Compute session did not provide a pipeline for the requested pop");
+    }
+    return {
+      session,
+      pipelineId,
+      accessToken,
+      accessTokenValidUntil: accessTokenValidUntil(session)
+    };
+  }
+  async getOnDemandComputeSession() {
+    let session = null;
+    const sessionsUrl = `${this.options.computeUrl}/v1/sessions`;
+    const headers = {
+      Authorization: await this.options.authorizationHeader()
+    };
+    let sessions;
+    if (!this.options.pop) {
+      this.options.requestLogger?.debug("fetching sessions from: %s", sessionsUrl);
+      const response = await this.options.httpClient.fetch(sessionsUrl, {
+        headers
+      });
+      if (response.status == 404) {
+        sessions = [];
+      } else if (response.status != 200) {
+        const message = await response.text();
+        throw new Error(`Unexpected status ${response.status} fetching compute sessions: ${message}`);
+      } else {
+        const response_content = await response.json();
+        sessions = response_content;
+      }
+      if (sessions.length > 0) {
+        this.options.logger?.debug(`User has ${sessions.length} sessions, inspecting for usable session`);
+        for (let s of sessions) {
+          if (!SESSION_DEAD.has(s.session_status) && !s.persistent && (!this.options.sessionName || s.session_name === this.options.sessionName)) {
+            session = s;
+            this.options.logger?.debug(`Use active session ${s.session_uuid} with pipeline ${pipelineIdFromSession(s)}`);
+            break;
+          }
+        }
+      }
+    }
+    if (!session) {
+      this.options.requestLogger?.debug("creating a new session at: %s", sessionsUrl);
+      const createBody = sessionCreateBody(this.options);
+      const createHeaders = {
+        ...headers,
+        ...createBody ? { "Content-Type": "application/json" } : {}
+      };
+      const request = {
+        headers: createHeaders,
+        method: "POST"
+      };
+      if (createBody) {
+        request.body = createBody;
+      }
+      const query = "wait=true";
+      const response = await this.options.httpClient.fetch(`${sessionsUrl}?${query}`, request);
+      if (response.status != 200) {
+        const message = await response.text();
+        throw new Error(`Unexpected status ${response.status} creating a compute session: ${message}`);
+      } else {
+        sessions = await response.json();
+      }
+      if (sessions.length == 0) {
+        throw new Error("Unexpected, no compute session after attempt to create one");
+      }
+      session = sessions[0] || null;
+    }
+    if (!session) {
+      throw new Error("unexpected undefined session");
+    }
+    if (this.options.pop && !pipelineIdFromSession(session)) {
+      throw new Error("Compute session did not provide a pipeline for the requested pop");
+    }
+    return session;
+  }
+  async getPermanentComputeSession(sessionUuid) {
+    let session = null;
+    const sessionUrl = `${this.options.computeUrl}/v1/sessions/${sessionUuid}`;
+    this.options.requestLogger?.debug("fetching session from: %s", sessionUrl);
+    const headers = {
+      Authorization: await this.options.authorizationHeader()
+    };
+    let response = await this.options.httpClient.fetch(sessionUrl, {
+      headers
+    });
+    if (response.status == 404) {
+      throw new Error(`Unexpected status ${response.status} compute sessions ${sessionUuid} not found`);
+    } else if (response.status != 200) {
+      const message = await response.text();
+      throw new Error(`Unexpected status ${response.status} fetching compute sessions: ${message}`);
+    } else {
+      const response_content = await response.json();
+      session = response_content;
+    }
+    return session;
+  }
+  sessionAccessToken(session) {
+    if (!session.access_token) {
+      throw new Error(`Compute session ${session.session_uuid} did not provide an access token`);
+    }
+    return session.access_token;
+  }
+  async waitUntilReady(session, accessToken) {
+    let isReady = false;
+    const deadline = Date.now() + this.options.readyTimeoutMs;
+    while (!isReady) {
+      const health_url = `${session.session_endpoint}/health`;
+      const response = await this.options.httpClient.fetch(health_url, {
+        headers: {
+          Authorization: `Bearer ${accessToken}`,
+          Accept: "application/json"
+        }
+      });
+      if (response.status == 200) {
+        const contentType = response.headers.get("content-type") || "";
+        const body = await response.text();
+        try {
+          isReady = sessionHealthReady(body, contentType);
+        } catch (error) {
+          this.options.logger?.debug(`session ${session.session_uuid} health check returned invalid JSON, wait and poll for update`);
+        }
+        if (!isReady && Date.now() > deadline) {
+          throw new Error(`Created session ${session.session_uuid} did not become healthy after ${this.options.readyTimeoutMs / 1e3} seconds`);
+        }
+        if (!isReady) {
+          this.options.logger?.debug(`session ${session.session_uuid} health check not ready, wait and poll for update`);
+          await sleep(CHECK_FOR_IS_READY_INTERVAL);
+        }
+      } else if (Date.now() > deadline) {
+        throw new Error(`Created session ${session.session_uuid} did not become healthy after ${this.options.readyTimeoutMs / 1e3} seconds`);
+      } else {
+        this.options.logger?.debug(`session ${session.session_uuid} health check status ${response.status}, wait and poll for update`);
+        await sleep(CHECK_FOR_IS_READY_INTERVAL);
+      }
+    }
+  }
+};
+
 // types.ts
 var EndpointState = /* @__PURE__ */ ((EndpointState2) => {
   EndpointState2["Idle"] = "Idle";
@@ -8644,6 +8842,7 @@ var EndpointState = /* @__PURE__ */ ((EndpointState2) => {
 })(EndpointState || {});
 
 // streaming.ts
+import { v4 as uuidv4 } from "uuid";
 var Stream = class _Stream {
   constructor(iterator, controller) {
     this.iterator = iterator;
@@ -8824,6 +9023,76 @@ function readableStreamFromString(s) {
     }
   });
 }
+function randomMultipartBoundary() {
+  return `----formdata-boundary-${uuidv4()}`;
+}
+function toPartStream(content) {
+  if (content instanceof ReadableStream) {
+    return content;
+  }
+  if (content instanceof Blob) {
+    return content.stream();
+  }
+  const bytes = ArrayBuffer.isView(content) ? new Uint8Array(content.buffer, content.byteOffset, content.byteLength) : new Uint8Array(content);
+  return new ReadableStream({
+    start(controller) {
+      controller.enqueue(bytes);
+      controller.close();
+    }
+  });
+}
+async function cancelMultipartContent(content, reason) {
+  if (content instanceof ReadableStream) {
+    await content.cancel(reason);
+  }
+}
+function encodeMultipartFormData(parts, boundary) {
+  const encoder = new TextEncoder();
+  let partIndex = 0;
+  let reader = null;
+  return new ReadableStream({
+    async pull(controller) {
+      if (reader) {
+        const { done, value } = await reader.read();
+        if (!done) {
+          controller.enqueue(value);
+          return;
+        }
+        reader = null;
+        controller.enqueue(encoder.encode("\r\n"));
+        partIndex++;
+      }
+      if (partIndex >= parts.length) {
+        controller.enqueue(encoder.encode(`--${boundary}--\r
+`));
+        controller.close();
+        return;
+      }
+      const part = parts[partIndex];
+      let header = `--${boundary}\r
+Content-Disposition: form-data; name="${part.name}"\r
+`;
+      if (part.contentType) {
+        header += `Content-Type: ${part.contentType}\r
+`;
+      }
+      header += "\r\n";
+      controller.enqueue(encoder.encode(header));
+      if (typeof part.content === "string") {
+        controller.enqueue(encoder.encode(part.content));
+        controller.enqueue(encoder.encode("\r\n"));
+        partIndex++;
+      } else {
+        reader = toPartStream(part.content).getReader();
+      }
+    },
+    async cancel(reason) {
+      await reader?.cancel(reason);
+      const firstUnstartedPart = reader ? partIndex + 1 : partIndex;
+      await Promise.all(parts.slice(firstUnstartedPart).map((part) => cancelMultipartContent(part.content, reason)));
+    }
+  });
+}
 
 // worker/worker_types.ts
 var PredictionVersion = /* @__PURE__ */ ((PredictionVersion3) => {
@@ -8881,7 +9150,7 @@ var ContourType = /* @__PURE__ */ ((ContourType2) => {
 })(ContourType || {});
 
 // worker/webrtc_whip.ts
-import { v4 as uuidv4 } from "uuid";
+import { v4 as uuidv42 } from "uuid";
 
 // worker/webrtc_base.ts
 import path from "path";
@@ -9156,7 +9425,7 @@ var WebrtcBase = class _WebrtcBase {
 // 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);
+    super(getSession, client, uuidv42().toString(), "liveIngress/whip", is_pipeline_direct, requestLogger);
     this._stream = stream;
   }
   async start() {
@@ -9551,6 +9820,111 @@ var LoadFromJob = class extends AbstractJob {
     });
   }
 };
+var UploadGroupJob = class extends AbstractJob {
+  get [Symbol.toStringTag]() {
+    return "uploadGroupJob";
+  }
+  constructor(sources, params, getSession, client, requestLogger) {
+    super(params, getSession, client, requestLogger);
+    if (sources.length === 0) {
+      throw new Error("upload group requires at least one source");
+    }
+    this._sources = sources;
+  }
+  async startJob() {
+    const session = await this._getSession();
+    if (!session.baseUrl) {
+      return Promise.reject(new Error("session.baseUrl must not be null"));
+    }
+    const queryParams = new URLSearchParams({
+      mode: "queue",
+      processing: "sync"
+    });
+    if (this._version !== void 0) {
+      queryParams.set("version", this._version.toString());
+    }
+    if (this._params.motionDetect) {
+      for (const [key, value] of Object.entries(this._params.motionDetect)) {
+        queryParams.set(key, value);
+      }
+    }
+    const postUrl = `${session.baseUrl.replace(/\/+$/, "")}/pipelines/${session.pipelineId}/source?${queryParams.toString()}`;
+    const parts = [];
+    if (this._params.componentParams) {
+      parts.push({ name: "params", contentType: "application/json", content: JSON.stringify(this._params.componentParams) });
+    }
+    if (this._params.roi) {
+      parts.push({ name: "roi", contentType: "application/json", content: JSON.stringify(this._params.roi) });
+    }
+    if (this._params.fps) {
+      parts.push({ name: "fps", contentType: "application/json", content: JSON.stringify(this._params.fps) });
+    }
+    for (const source of this._sources) {
+      parts.push({ name: "file", contentType: source.mimeType, content: source.stream });
+    }
+    const boundary = randomMultipartBoundary();
+    const headers = {
+      ...session.authenticationHeaders(),
+      Accept: "application/jsonl",
+      "Content-Type": `multipart/form-data; boundary=${boundary}`
+    };
+    return await this._client.fetch(postUrl, {
+      headers,
+      method: "POST",
+      body: encodeMultipartFormData(parts, boundary),
+      signal: this._controller.signal,
+      // @ts-ignore
+      duplex: "half",
+      eyepop: { responseStreaming: true }
+    });
+  }
+};
+var LoadFromGroupJob = class extends AbstractJob {
+  get [Symbol.toStringTag]() {
+    return "loadFromGroupJob";
+  }
+  constructor(urls, params, getSession, client, requestLogger) {
+    super(params, getSession, client, requestLogger);
+    if (urls.length === 0) {
+      throw new Error("load from group requires at least one url");
+    }
+    this._urls = urls;
+  }
+  async startJob() {
+    const session = await this._getSession();
+    if (!session.baseUrl) {
+      return Promise.reject(new Error("session.baseUrl must not be null"));
+    }
+    const body = {
+      sourceType: "GROUP",
+      sources: this._urls.map((url) => ({ sourceType: "URL", url })),
+      version: this._version
+    };
+    if (this._params.componentParams) {
+      body["params"] = this._params.componentParams;
+    }
+    if (this._params.roi) {
+      body["roi"] = this._params.roi;
+    }
+    if (this._params.motionDetect) {
+      Object.assign(body, this._params.motionDetect);
+    }
+    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 }
+    });
+  }
+};
 var LoadFromAssetUuidJob = class extends AbstractJob {
   constructor(assetUuid, params, getSession, client, requestLogger) {
     super(params, getSession, client, requestLogger);
@@ -10152,21 +10526,6 @@ var TransientPopId = /* @__PURE__ */ ((TransientPopId2) => {
 })(TransientPopId || {});
 
 // worker/worker_endpoint.ts
-var SessionStatus = /* @__PURE__ */ ((SessionStatus2) => {
-  SessionStatus2["UNKNOWN"] = "unknown";
-  SessionStatus2["PENDING"] = "pending";
-  SessionStatus2["RUNNING"] = "running";
-  SessionStatus2["STOPPED"] = "stopped";
-  SessionStatus2["FAILED"] = "failed";
-  SessionStatus2["ERROR"] = "error";
-  SessionStatus2["PIPELINE_CREATING"] = "pipeline_creating";
-  SessionStatus2["PIPELINE_OK"] = "pipeline_ok";
-  SessionStatus2["PIPELINE_CHECKING"] = "pipeline_checking";
-  SessionStatus2["PIPELINE_ERROR"] = "pipeline_error";
-  SessionStatus2["UPGRADING"] = "upgrading";
-  return SessionStatus2;
-})(SessionStatus || {});
-var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 var _WorkerEndpoint = class _WorkerEndpoint extends Endpoint {
   constructor(options) {
     super(options);
@@ -10329,6 +10688,114 @@ var _WorkerEndpoint = class _WorkerEndpoint extends Endpoint {
       return Promise.reject("unknown source type");
     }
   }
+  async uploadGroup(paths, params = {}) {
+    if (paths.length === 0) {
+      throw new Error("upload group requires at least one path");
+    }
+    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 sources = await Promise.all(
+        paths.map(async (path2) => {
+          let streamSource;
+          if (this._options.platformSupport?.resolvePath) {
+            streamSource = await this._options.platformSupport.resolvePath({ path: path2 }, this._logger);
+          } else {
+            streamSource = await resolvePath({ path: path2 }, this._logger);
+          }
+          return { stream: streamSource.stream, mimeType: streamSource.mimeType };
+        })
+      );
+      const job = new UploadGroupJob(
+        sources,
+        params,
+        async () => 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 uploadStreamGroup(streams, mimeTypes, params = {}) {
+    if (streams.length === 0) {
+      throw new Error("upload stream group requires at least one stream");
+    }
+    if (mimeTypes !== void 0 && mimeTypes.length !== streams.length) {
+      throw new Error("mimeTypes must have the same length as streams");
+    }
+    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 sources = streams.map((stream, i) => ({
+        stream,
+        mimeType: mimeTypes?.[i] ?? null
+      }));
+      const job = new UploadGroupJob(
+        sources,
+        params,
+        async () => 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 loadFromGroup(urls, params = {}) {
+    if (urls.length === 0) {
+      throw new Error("load from group requires at least one url");
+    }
+    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 LoadFromGroupJob(
+        urls,
+        params,
+        async () => 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 uploadFile(source, params) {
     await this.ensureTransientPipelineStarted();
     if (!this._baseUrl || !this._pipelineId || !this._client || !this._limit) {
@@ -10649,161 +11116,38 @@ var _WorkerEndpoint = class _WorkerEndpoint extends Endpoint {
     const seconds = this.options().sessionReadyTimeoutSeconds;
     return typeof seconds == "number" && Number.isFinite(seconds) && seconds > 0 ? seconds * 1e3 : _WorkerEndpoint.WAIT_FOR_IS_READY;
   }
-  sessionHealthReady(body, contentType) {
-    if (contentType.includes("application/json")) {
-      const health = JSON.parse(body);
-      if (health && typeof health == "object") {
-        if (health.message && !health.session_status) {
-          return true;
-        }
-        return health.session_status == "running" /* RUNNING */;
-      }
-    }
-    return contentType.includes("text/plain") && body.includes("I'm fine");
-  }
   async getComputeSession() {
     if (!this._client) {
       throw new Error("endpoint not initialized");
     }
-    let session;
-    const sessionUuid = this.options().sessionUuid;
-    if (sessionUuid) {
-      session = await this.getPermanentComputeSession(this._client, sessionUuid);
-    } else {
-      session = await this.getOnDemandComputeSession(this._client);
-    }
-    this.setComputeSessionAccessToken(session);
-    const headers = {
-      Authorization: await this.authorizationHeader()
-    };
-    let isReady = false;
-    const readyTimeoutMs = this.sessionReadyTimeoutMs();
-    const deadline = Date.now() + readyTimeoutMs;
-    while (!isReady) {
-      const health_url = `${session.session_endpoint}/health`;
-      const response = await this._client.fetch(health_url, {
-        headers: {
-          ...headers,
-          Accept: "application/json"
-        }
-      });
-      if (response.status == 200) {
-        const contentType = response.headers.get("content-type") || "";
-        const body = await response.text();
-        try {
-          isReady = this.sessionHealthReady(body, contentType);
-        } catch (error) {
-          this._logger.debug(`session ${session.session_uuid} health check returned invalid JSON, wait and poll for update`);
-        }
-        if (!isReady && Date.now() > deadline) {
-          throw new Error(`Created session ${session.session_uuid} did not become healthy after ${readyTimeoutMs / 1e3} seconds`);
-        }
-        if (!isReady) {
-          this._logger.debug(`session ${session.session_uuid} health check not ready, wait and poll for update`);
-          await sleep(_WorkerEndpoint.CHECK_FOR_IS_READY_INTERVAL);
-        }
-      } else if (Date.now() > deadline) {
-        throw new Error(`Created session ${session.session_uuid} did not become healthy after ${readyTimeoutMs / 1e3} seconds`);
-      } else {
-        this._logger.debug(`session ${session.session_uuid} health check status ${response.status}, wait and poll for update`);
-        await sleep(_WorkerEndpoint.CHECK_FOR_IS_READY_INTERVAL);
-      }
+    let resolved;
+    try {
+      resolved = await new ComputeSessionClient({
+        computeUrl: this.eyepopUrl(),
+        httpClient: this._client,
+        authorizationHeader: () => this.computeAuthorizationHeader(),
+        sessionUuid: this.options().sessionUuid,
+        sessionName: this.options().sessionName,
+        pipelineImage: this.options().pipelineImage,
+        pipelineVersion: this.options().pipelineVersion,
+        pop: this.options().pop,
+        readyTimeoutMs: this.sessionReadyTimeoutMs(),
+        logger: this._logger,
+        requestLogger: this._requestLogger
+      }).resolve();
+    } catch (error) {
+      this.updateState("Error" /* Error */);
+      throw error;
     }
-    this._baseUrl = session.session_endpoint;
+    this._sessionAccessToken = resolved.accessToken;
+    this._sessionAccessTokenValidUntil = resolved.accessTokenValidUntil;
+    this._baseUrl = resolved.session.session_endpoint;
     this._pipeline = null;
-    this._pipelineId = this.pipelineIdFromSession(session);
+    this._pipelineId = resolved.pipelineId;
     if (this.options().pop) {
       this.setTransientPipelinePop();
     }
   }
-  async getOnDemandComputeSession(httpClient) {
-    let session = null;
-    const sessionsUrl = `${this.eyepopUrl()}/v1/sessions`;
-    const headers = {
-      Authorization: await this.computeAuthorizationHeader()
-    };
-    let sessions;
-    if (!this.options().pop) {
-      this._requestLogger.debug("fetching sessions from: %s", sessionsUrl);
-      const response = await httpClient.fetch(sessionsUrl, {
-        headers
-      });
-      if (response.status == 404) {
-        sessions = [];
-      } else if (response.status != 200) {
-        this.updateState("Error" /* Error */);
-        const message = await response.text();
-        throw new Error(`Unexpected status ${response.status} fetching compute sessions: ${message}`);
-      } else {
-        const response_content = await response.json();
-        sessions = response_content;
-      }
-      if (sessions.length > 0) {
-        this._logger.debug(`User has ${sessions.length} sessions, inspecting for usable session`);
-        for (let s of sessions) {
-          if (!_WorkerEndpoint.SESSION_DEAD.has(s.session_status) && !s.persistent) {
-            session = s;
-            this._logger.debug(`Use active session ${s.session_uuid} with pipeline ${this.pipelineIdFromSession(s)}`);
-            break;
-          }
-        }
-      }
-    }
-    if (!session) {
-      this._requestLogger.debug("creating a new session at: %s", sessionsUrl);
-      const createBody = this.sessionCreateBody();
-      const createHeaders = {
-        ...headers,
-        ...createBody ? { "Content-Type": "application/json" } : {}
-      };
-      const request = {
-        headers: createHeaders,
-        method: "POST"
-      };
-      if (createBody) {
-        request.body = createBody;
-      }
-      const response = await httpClient.fetch(`${sessionsUrl}?wait=true`, request);
-      if (response.status != 200) {
-        this.updateState("Error" /* Error */);
-        const message = await response.text();
-        throw new Error(`Unexpected status ${response.status} creating a compute session: ${message}`);
-      } else {
-        sessions = await response.json();
-      }
-      if (sessions.length == 0) {
-        throw new Error("Unexpected, no compute session after attempt to create one");
-      }
-      session = sessions[0] || null;
-    }
-    if (!session) {
-      throw new Error("unexpected undefined session");
-    }
-    return session;
-  }
-  async getPermanentComputeSession(httpClient, sessionUuid) {
-    let session = null;
-    const sessionUrl = `${this.eyepopUrl()}/v1/sessions/${sessionUuid}`;
-    this._requestLogger.debug("fetching session from: %s", sessionUrl);
-    const headers = {
-      Authorization: await this.computeAuthorizationHeader()
-    };
-    let response = await httpClient.fetch(sessionUrl, {
-      headers
-    });
-    if (response.status == 404) {
-      this.updateState("Error" /* Error */);
-      throw new Error(`Unexpected status ${response.status} compute sessions ${sessionUuid} not found`);
-    } else if (response.status != 200) {
-      this.updateState("Error" /* Error */);
-      const message = await response.text();
-      throw new Error(`Unexpected status ${response.status} fetching compute sessions: ${message}`);
-    } else {
-      const response_content = await response.json();
-      session = response_content;
-    }
-    return session;
-  }
   async startTransientPipeline() {
     const client = this._client;
     const baseUrl = this._baseUrl;
@@ -10860,6 +11204,13 @@ var _WorkerEndpoint = class _WorkerEndpoint extends Endpoint {
     if (this._pipelineId) {
       return;
     }
+    if (this.options().pop) {
+      await this.reconnect();
+      if (!this._pipelineId) {
+        throw new Error("Compute session did not provide a pipeline for the requested pop");
+      }
+      return;
+    }
     if (!this._pipelineCreatePromise) {
       this._pipelineCreatePromise = this.startTransientPipeline();
     }
@@ -10875,7 +11226,9 @@ var _WorkerEndpoint = class _WorkerEndpoint extends Endpoint {
       throw new Error("endpoint not initialized");
     }
     const previousPop = this.options().pop;
-    const previousPipeline = this._pipeline;
+    const previousBaseUrl = this._baseUrl;
+    const previousSessionAccessToken = this._sessionAccessToken;
+    const previousSessionAccessTokenValidUntil = this._sessionAccessTokenValidUntil;
     if (this._pipelineId) {
       await this.deleteTransientPipeline(this._pipelineId);
       this._pipelineId = null;
@@ -10883,10 +11236,14 @@ var _WorkerEndpoint = class _WorkerEndpoint extends Endpoint {
     this._pipeline = null;
     try {
       this.options().pop = pop;
-      await this.ensureTransientPipelineStarted();
+      await this.getComputeSession();
     } catch (error) {
       this.options().pop = previousPop;
-      this._pipeline = previousPipeline;
+      this._pipeline = null;
+      this._pipelineId = null;
+      this._baseUrl = previousPop ? null : previousBaseUrl;
+      this._sessionAccessToken = previousSessionAccessToken;
+      this._sessionAccessTokenValidUntil = previousSessionAccessTokenValidUntil;
       throw error;
     }
     if (!this._pipelineId) {
@@ -10911,13 +11268,6 @@ var _WorkerEndpoint = class _WorkerEndpoint extends Endpoint {
       this._logger.info(`stopping pipeline failed, status ${response.status}: ${message}`);
     }
   }
-  pipelineIdFromSession(session) {
-    if (session.pipeline_uuid) {
-      return session.pipeline_uuid;
-    }
-    const pipeline = session.pipelines?.[0];
-    return pipeline?.id || pipeline?.pipeline_id || null;
-  }
   async authorizationHeader() {
     if (this._sessionAccessToken) {
       return `Bearer ${this._sessionAccessToken}`;
@@ -10933,20 +11283,6 @@ var _WorkerEndpoint = class _WorkerEndpoint extends Endpoint {
     }
     return super.authorizationHeader();
   }
-  setComputeSessionAccessToken(session) {
-    if (!session.access_token) {
-      throw new Error(`Compute session ${session.session_uuid} did not provide an access token`);
-    }
-    this._sessionAccessToken = session.access_token;
-    if (session.access_token_expires_at) {
-      const expiresAt = Date.parse(session.access_token_expires_at);
-      this._sessionAccessTokenValidUntil = Number.isNaN(expiresAt) ? null : expiresAt;
-    } else if (session.access_token_expires_in) {
-      this._sessionAccessTokenValidUntil = Date.now() + session.access_token_expires_in * 1e3;
-    } else {
-      this._sessionAccessTokenValidUntil = null;
-    }
-  }
   setTransientPipelinePop() {
     const pop = this.options().pop;
     if (pop && this._pipelineId) {
@@ -10958,26 +11294,8 @@ var _WorkerEndpoint = class _WorkerEndpoint extends Endpoint {
       };
     }
   }
-  sessionCreateBody() {
-    const body = {};
-    if (this.options().sessionName) {
-      body.session_name = this.options().sessionName;
-    }
-    if (this.options().pipelineImage) {
-      body.pipeline_image = this.options().pipelineImage;
-    }
-    if (this.options().pipelineVersion) {
-      body.pipeline_version = this.options().pipelineVersion;
-    }
-    if (this.options().pop) {
-      body.pop = this.options().pop;
-    }
-    return Object.keys(body).length > 0 ? JSON.stringify(body) : void 0;
-  }
 };
-_WorkerEndpoint.SESSION_DEAD = /* @__PURE__ */ new Set(["error" /* ERROR */, "failed" /* FAILED */, "stopped" /* STOPPED */, "pipeline_error" /* PIPELINE_ERROR */, "unknown" /* UNKNOWN */]);
 _WorkerEndpoint.WAIT_FOR_IS_READY = 60 * 1e3;
-_WorkerEndpoint.CHECK_FOR_IS_READY_INTERVAL = 250;
 var WorkerEndpoint = _WorkerEndpoint;
 
 // shims/websockets.ts
@@ -12468,6 +12786,7 @@ export {
   ForwardOperatorType,
   InferenceType,
   LoadFromAssetUuidJob,
+  LoadFromGroupJob,
   LoadFromJob,
   LoadMediaStreamJob,
   ModelExportStatus,
@@ -12481,12 +12800,12 @@ export {
   PopComponentType,
   PredictionVersion,
   Semaphore,
-  SessionStatus,
   Stream,
   TaskMode,
   TaskType,
   TranscodeMode,
   TransientPopId,
+  UploadGroupJob,
   UploadJob,
   UserReview,
   VideoMode,
@@ -12497,7 +12816,9 @@ export {
   WorkerEndpoint,
   WorkflowPhase,
   index_default as default,
+  encodeMultipartFormData,
   getBaseUrl,
+  randomMultipartBoundary,
   readableStreamFromString
 };
 /*! Bundled license information: