@eyepop.ai/eyepop 3.15.1 → 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);
@@ -9717,8 +10091,9 @@ if ("document" in globalThis && "implementation" in globalThis.document) {
   };
 } else {
   class NodeHttpClient {
-    constructor(agent, logger) {
+    constructor(agent, fetchFn, logger) {
       this._agent = agent;
+      this._fetch = fetchFn;
       this._logger = logger;
     }
     async fetch(input, init) {
@@ -9726,7 +10101,7 @@ if ("document" in globalThis && "implementation" in globalThis.document) {
       init.dispatcher = this._agent;
       const logLine = logLineFromRequest(input, init);
       this._logger.debug(`Node fetch() BEFORE ${logLine}`);
-      const response = await fetch(input, init);
+      const response = await this._fetch(input, init);
       this._logger.debug(`AFTER ${logLine} -> ${response.status}`);
       return response;
     }
@@ -9746,7 +10121,7 @@ if ("document" in globalThis && "implementation" in globalThis.document) {
       pipelining: 0
     });
     logger.debug("Using node fetch with undici agent as http client");
-    return new NodeHttpClient(agent, logger);
+    return new NodeHttpClient(agent, undici.fetch, logger);
   };
 }
 
@@ -10151,20 +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";
-  return SessionStatus2;
-})(SessionStatus || {});
-var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 var _WorkerEndpoint = class _WorkerEndpoint extends Endpoint {
   constructor(options) {
     super(options);
@@ -10172,7 +10533,10 @@ var _WorkerEndpoint = class _WorkerEndpoint extends Endpoint {
     this._baseUrl = null;
     this._pipelineId = null;
     this._popName = null;
+    this._sessionAccessToken = null;
+    this._sessionAccessTokenValidUntil = null;
     this._pipeline = null;
+    this._pipelineCreatePromise = null;
   }
   options() {
     return this._options;
@@ -10199,20 +10563,29 @@ var _WorkerEndpoint = class _WorkerEndpoint extends Endpoint {
     this._baseUrl = null;
   }
   async session() {
-    const session = await super.session();
-    if (this._baseUrl == null || this._pipelineId == null) {
+    let session = null;
+    if (this._baseUrl == null) {
       await this.reconnect();
-      if (this._baseUrl == null || this._pipelineId == null) {
+      if (this._baseUrl == null) {
         return Promise.reject("endpoint not connected");
       }
     }
+    if (this._sessionAccessToken) {
+      session = {
+        eyepopUrl: this.options().eyepopUrl,
+        accessToken: this._sessionAccessToken,
+        validUntil: this._sessionAccessTokenValidUntil || Number.MAX_VALUE
+      };
+    } else {
+      session = await super.session();
+    }
     return {
       eyepopUrl: session.eyepopUrl,
       accessToken: session.accessToken,
       validUntil: session.validUntil,
       popId: this.options().popId,
       baseUrl: this._baseUrl,
-      pipelineId: this._pipelineId,
+      pipelineId: this._pipelineId || void 0,
       authenticationHeaders: () => this._authenticationHeaders(session)
     };
   }
@@ -10222,11 +10595,14 @@ var _WorkerEndpoint = class _WorkerEndpoint extends Endpoint {
   pop() {
     if (this._pipeline) {
       return this._pipeline.pop || null;
-    } else {
-      return null;
     }
+    return this.options().pop || null;
   }
   async changePop(pop) {
+    if (this.options().popId == "transient" /* Transient */) {
+      await this.changeTransientPop(pop);
+      return;
+    }
     const client = this._client;
     const baseUrl = this._baseUrl;
     if (!baseUrl || !client) {
@@ -10249,6 +10625,7 @@ var _WorkerEndpoint = class _WorkerEndpoint extends Endpoint {
       const message = await response.text();
       throw new Error(`Unexpected status ${response.status}: ${message}`);
     }
+    this.options().pop = pop;
     if (this._pipeline) {
       this._pipeline.pop = pop;
     } else {
@@ -10263,6 +10640,10 @@ var _WorkerEndpoint = class _WorkerEndpoint extends Endpoint {
   _authenticationHeaders(session) {
     return this._options.auth.isLocal !== void 0 ? {} : { Authorization: `Bearer ${session.accessToken}` };
   }
+  /**
+   * @deprecated Pop ids are only retained for backwards compatibility.
+   * Configure transient sessions with `WorkerOptions.pop`.
+   */
   popId() {
     return this.options().popId || null;
   }
@@ -10307,7 +10688,116 @@ 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) {
       return Promise.reject("endpoint not connected, use connect()");
     }
@@ -10340,6 +10830,7 @@ var _WorkerEndpoint = class _WorkerEndpoint extends Endpoint {
     }
   }
   async uploadStream(source, params) {
+    await this.ensureTransientPipelineStarted();
     if (!this._baseUrl || !this._pipelineId || !this._client || !this._limit) {
       return Promise.reject("endpoint not connected, use connect()");
     }
@@ -10372,6 +10863,7 @@ var _WorkerEndpoint = class _WorkerEndpoint extends Endpoint {
     }
   }
   async uploadPath(source, params) {
+    await this.ensureTransientPipelineStarted();
     if (!this._baseUrl || !this._pipelineId || !this._client || !this._limit) {
       throw new Error("endpoint not connected, use connect()");
     }
@@ -10418,6 +10910,7 @@ var _WorkerEndpoint = class _WorkerEndpoint extends Endpoint {
         params
       );
     }
+    await this.ensureTransientPipelineStarted();
     if (!this._baseUrl || !this._pipelineId || !this._client || !this._limit) {
       throw new Error("endpoint not connected, use connect()");
     }
@@ -10447,6 +10940,7 @@ var _WorkerEndpoint = class _WorkerEndpoint extends Endpoint {
     }
   }
   async loadFromAssetUuid(source, params) {
+    await this.ensureTransientPipelineStarted();
     if (!this._baseUrl || !this._pipelineId || !this._client || !this._limit) {
       throw new Error("endpoint not connected, use connect()");
     }
@@ -10476,6 +10970,7 @@ var _WorkerEndpoint = class _WorkerEndpoint extends Endpoint {
     }
   }
   async loadMediaStream(source, params) {
+    await this.ensureTransientPipelineStarted();
     if (!this._baseUrl || !this._pipelineId || !this._client || !this._limit) {
       throw new Error("endpoint not connected, use connect()");
     }
@@ -10518,7 +11013,9 @@ var _WorkerEndpoint = class _WorkerEndpoint extends Endpoint {
   async reconnect() {
     if (this.options().popId == "transient" /* Transient */) {
       await this.getComputeSession();
-      this._pipelineId = await this.startTransientPipeline();
+      if (this.options().pop) {
+        this.setTransientPipelinePop();
+      }
     } else if (this.options().sessionUuid) {
       await this.getComputeSession();
     } else {
@@ -10615,120 +11112,41 @@ var _WorkerEndpoint = class _WorkerEndpoint extends Endpoint {
       }
     }
   }
+  sessionReadyTimeoutMs() {
+    const seconds = this.options().sessionReadyTimeoutSeconds;
+    return typeof seconds == "number" && Number.isFinite(seconds) && seconds > 0 ? seconds * 1e3 : _WorkerEndpoint.WAIT_FOR_IS_READY;
+  }
   async getComputeSession() {
     if (!this._client) {
       throw new Error("endpoint not initialized");
     }
-    let session;
-    let headers;
-    const sessionUuid = this.options().sessionUuid;
-    if (sessionUuid) {
-      [session, headers] = await this.getPermanentComputeSession(this._client, sessionUuid);
-    } else {
-      [session, headers] = await this.getOnDemandComputeSession(this._client);
-    }
-    let isReady = false;
-    const deadline = Date.now() + _WorkerEndpoint.WAIT_FOR_IS_READY;
-    while (!isReady) {
-      const health_url = `${session.session_endpoint}/health`;
-      const response = await this._client.fetch(health_url, {
-        headers
-      });
-      if (response.status < 300) {
-        isReady = true;
-      } else if (Date.now() > deadline) {
-        throw new Error(`Created session ${session.session_uuid} did not become healthy after ${_WorkerEndpoint.WAIT_FOR_IS_READY / 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);
-      }
-    }
-    this._baseUrl = session.session_endpoint;
-    this._pipeline = null;
-    if (session.pipeline_uuid) {
-      this._pipelineId = session.pipeline_uuid;
-    } else if (session.pipelines) {
-      this._pipelineId = session.pipelines[0].pipeline_id;
-    } else {
-      this._pipelineId = null;
-    }
-  }
-  async getOnDemandComputeSession(httpClient) {
-    let session = null;
-    const sessionsUrl = `${this.eyepopUrl()}/v1/sessions`;
-    this._requestLogger.debug("fetching sessions from: %s", sessionsUrl);
-    const headers = {
-      Authorization: await this.authorizationHeader()
-    };
-    let response = await httpClient.fetch(sessionsUrl, {
-      headers
-    });
-    let sessions;
-    if (response.status == 404) {
-      sessions = [];
-    } else if (response.status != 200) {
+    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 */);
-      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 ${s.pipeline_uuid}`);
-          break;
-        }
-      }
+      throw error;
     }
-    if (!session) {
-      this._requestLogger.debug("creating a new session at: %s", sessionsUrl);
-      response = await httpClient.fetch(`${sessionsUrl}?wait=true`, {
-        headers,
-        method: "POST"
-      });
-      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, headers];
-  }
-  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.authorizationHeader()
-    };
-    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;
+    this._sessionAccessToken = resolved.accessToken;
+    this._sessionAccessTokenValidUntil = resolved.accessTokenValidUntil;
+    this._baseUrl = resolved.session.session_endpoint;
+    this._pipeline = null;
+    this._pipelineId = resolved.pipelineId;
+    if (this.options().pop) {
+      this.setTransientPipelinePop();
     }
-    return [session, headers];
   }
   async startTransientPipeline() {
     const client = this._client;
@@ -10737,12 +11155,12 @@ var _WorkerEndpoint = class _WorkerEndpoint extends Endpoint {
       throw new Error("endpoint not initialized");
     }
     let pop;
-    if (this._pipeline && this._pipeline.pop) {
+    if (this.options().pop) {
+      pop = this.options().pop;
+    } else if (this._pipeline && this._pipeline.pop) {
       pop = this._pipeline.pop;
     } else {
-      pop = {
-        components: []
-      };
+      throw new Error("Cannot start a transient pipeline without a pop");
     }
     const body = {
       pop,
@@ -10754,8 +11172,9 @@ var _WorkerEndpoint = class _WorkerEndpoint extends Endpoint {
       videoOutput: "no_output"
     };
     const post_url = `${baseUrl.replace(/\/+$/, "")}/pipelines`;
-    let response = await this.fetchWithRetry(async () => {
+    const response = await this.fetchWithRetry(async () => {
       let headers = {
+        Accept: "application/json",
         "Content-Type": "application/json",
         Authorization: await this.authorizationHeader()
       };
@@ -10767,15 +11186,116 @@ var _WorkerEndpoint = class _WorkerEndpoint extends Endpoint {
     });
     if (response.status != 200) {
       const message = await response.text();
-      throw new Error(`Unexpected status ${response.status}: ${message}`);
+      throw new Error(`Unexpected status ${response.status} starting transient pipeline: ${message.slice(0, 300)}`);
     }
     const result = await response.json();
     return result["id"];
   }
+  async ensureTransientPipelineStarted() {
+    if (this.options().popId != "transient" /* Transient */ || this._pipelineId) {
+      return;
+    }
+    if (!this.options().pop) {
+      return;
+    }
+    if (!this._baseUrl) {
+      await this.reconnect();
+    }
+    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();
+    }
+    try {
+      this._pipelineId = await this._pipelineCreatePromise;
+      this.setTransientPipelinePop();
+    } finally {
+      this._pipelineCreatePromise = null;
+    }
+  }
+  async changeTransientPop(pop) {
+    if (!this._client) {
+      throw new Error("endpoint not initialized");
+    }
+    const previousPop = this.options().pop;
+    const previousBaseUrl = this._baseUrl;
+    const previousSessionAccessToken = this._sessionAccessToken;
+    const previousSessionAccessTokenValidUntil = this._sessionAccessTokenValidUntil;
+    if (this._pipelineId) {
+      await this.deleteTransientPipeline(this._pipelineId);
+      this._pipelineId = null;
+    }
+    this._pipeline = null;
+    try {
+      this.options().pop = pop;
+      await this.getComputeSession();
+    } catch (error) {
+      this.options().pop = previousPop;
+      this._pipeline = null;
+      this._pipelineId = null;
+      this._baseUrl = previousPop ? null : previousBaseUrl;
+      this._sessionAccessToken = previousSessionAccessToken;
+      this._sessionAccessTokenValidUntil = previousSessionAccessTokenValidUntil;
+      throw error;
+    }
+    if (!this._pipelineId) {
+      throw new Error("Compute session did not provide a pipeline for the requested pop");
+    }
+    this.setTransientPipelinePop();
+  }
+  async deleteTransientPipeline(pipelineId) {
+    if (!this._client || !this._baseUrl) {
+      return;
+    }
+    const deleteUrl = `${this._baseUrl}/pipelines/${pipelineId}`;
+    const headers = {
+      Authorization: await this.authorizationHeader()
+    };
+    let response = await this._client.fetch(deleteUrl, {
+      method: "DELETE",
+      headers
+    });
+    if (response.status >= 300) {
+      const message = await response.text();
+      this._logger.info(`stopping pipeline failed, status ${response.status}: ${message}`);
+    }
+  }
+  async authorizationHeader() {
+    if (this._sessionAccessToken) {
+      return `Bearer ${this._sessionAccessToken}`;
+    }
+    return super.authorizationHeader();
+  }
+  async computeAuthorizationHeader() {
+    if (this.options().auth.isLocal !== void 0) {
+      return "Implicit";
+    }
+    if (this.options().auth.apiKey !== void 0) {
+      return `Bearer ${this.options().auth.apiKey}`;
+    }
+    return super.authorizationHeader();
+  }
+  setTransientPipelinePop() {
+    const pop = this.options().pop;
+    if (pop && this._pipelineId) {
+      this._pipeline = {
+        id: this._pipelineId,
+        state: "idle",
+        startTime: (/* @__PURE__ */ new Date()).toString(),
+        pop
+      };
+    }
+  }
 };
-_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
@@ -12149,6 +12669,15 @@ var EyePop;
     if (opts.sessionUuid === void 0) {
       opts.sessionUuid = readEnv("EYEPOP_SESSION_UUID");
     }
+    if (opts.sessionName === void 0) {
+      opts.sessionName = readEnv("EYEPOP_SESSION_NAME");
+    }
+    if (opts.pipelineImage === void 0) {
+      opts.pipelineImage = readEnv("EYEPOP_PIPELINE_IMAGE");
+    }
+    if (opts.pipelineVersion === void 0) {
+      opts.pipelineVersion = readEnv("EYEPOP_PIPELINE_VERSION");
+    }
     if (opts.popId === void 0 && opts.sessionUuid === void 0) {
       opts.popId = readEnv("EYEPOP_POP_ID") || "transient" /* Transient */;
     }
@@ -12257,6 +12786,7 @@ export {
   ForwardOperatorType,
   InferenceType,
   LoadFromAssetUuidJob,
+  LoadFromGroupJob,
   LoadFromJob,
   LoadMediaStreamJob,
   ModelExportStatus,
@@ -12270,12 +12800,12 @@ export {
   PopComponentType,
   PredictionVersion,
   Semaphore,
-  SessionStatus,
   Stream,
   TaskMode,
   TaskType,
   TranscodeMode,
   TransientPopId,
+  UploadGroupJob,
   UploadJob,
   UserReview,
   VideoMode,
@@ -12286,7 +12816,9 @@ export {
   WorkerEndpoint,
   WorkflowPhase,
   index_default as default,
+  encodeMultipartFormData,
   getBaseUrl,
+  randomMultipartBoundary,
   readableStreamFromString
 };
 /*! Bundled license information: